Paper deep dive
HiTS-CL: A Continual Learning Framework for Long-Horizon Temporal Knowledge Graph Extrapolation
Yansong Liu, Rui Liu, Yuan Zuo, Hongwei Zhao, Da Fu, Fuwei Zhang, Fuzhen Zhuang, Yong Chen, Zhe Li
Intelligence
Status: not_run | Model: - | Prompt: - | Confidence: 0%
Entities (0)
Relation Signals (0)
No relation signals yet.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Extrapolative temporal knowledge graph reasoning (TKGR) predicts future facts from historical snapshots. Most existing methods train once on an early prefix of the timeline and then use a frozen model for all future timestamps. We argue that this fixed-prefix protocol is misaligned with extrapolation. It learns from a static prefix, whereas the target stream is non-stationary: new entities and facts emerge, temporal dependencies shift across regimes, and recurring historical signals must be refreshed online. As a result, models trained only on early snapshots become outdated and degrade over long horizons. We address this mismatch by formulating extrapolative TKGR as continual learning over streaming snapshots. Under this view, effective extrapolation must jointly handle current dynamics, stable knowledge, and recurring historical evidence. Based on these requirements, we propose History-enhanced Two-Step Continual Learning (HiTS-CL), a backbone-agnostic continual learning framework for extrapolative TKGR. HiTS-CL tracks current dynamics via continual fine-tuning, preserves stable knowledge via multi-teacher adaptive distillation, and retains recurring historical evidence via a selective memory of recent and frequent facts. We integrate HiTS-CL into five representative TKGR backbones and evaluate it on four benchmark datasets. HiTS-CL consistently improves extrapolation accuracy, reduces long-horizon degradation, and outperforms strong continual-learning baselines, including a recent method for temporal knowledge graphs. Source code and data are available at this https URL.
Tags
Links
- Source: https://arxiv.org/abs/2609.36559v1
- Canonical: https://arxiv.org/abs/2609.36559v1
Trouble viewing inline? Open PDF directly →
Full Text
61,974 characters extracted from source content.
Expand or collapse full text
HiTS-CL: A Continual Learning Framework for Long-Horizon Temporal Knowledge Graph Extrapolation Conference: Proceedings of the 35th ACM International Conference on Information and Knowledge Management; November 7–11, 2026; Rome, Italy.Proceedings of the 35th ACM International Conference on Information and Knowledge Management (CIKM ’26), November 7–11, 2026, Rome, ItalyISBN: 979-8-4007-2539-5/2026/11DOI: 10.1145/3799682.3840860CCS: Computing methodologies Temporal reasoningCCS: Computing methodologies Knowledge representation and reasoning Yansong Liu email: liuyansong@buaa.edu.cn Affiliation: Beihang University, Beijing, China , Rui Liu email: lr@buaa.edu.cn Affiliation: Beihang University, Beijing, China , Yuan Zuo Note: corresponding authors. email: zuoyuan@buaa.edu.cn Affiliation: Beihang University, Beijing, China , Hongwei Zhao email: zhaohongwei@buaa.edu.cn Affiliation: Beihang University, Beijing, China , Da Fu email: fuda@buaa.edu.cn Affiliation: Beihang University, Beijing, China , Fuwei Zhang email: fuwei.zhang@foxmail.com Affiliation: Beihang University, Beijing, China , Fuzhen Zhuang email: zhuangfuzhen@buaa.edu.cn Affiliation: School of Artificial Intelligence, Beihang University, Beijing, China , Yong Chen email: alphawolf.chen@gmail.com Affiliation: Beijing University of Posts and Telecommunications, Beijing, China and Zhe Li email: lizhe_hbeu@vip.163.com Affiliation: Hubei Engineering University, Xiaogan, Hubei, China © c Abstract. Extrapolative temporal knowledge graph reasoning (TKGR) predicts future facts from historical snapshots. Most existing methods train once on an early prefix of the timeline and then use a frozen model for all future timestamps. We argue that this fixed-prefix protocol is misaligned with extrapolation. It learns from a static prefix, whereas the target stream is non-stationary: new entities and facts emerge, temporal dependencies shift across regimes, and recurring historical signals must be refreshed online. As a result, models trained only on early snapshots become outdated and degrade over long horizons. We address this mismatch by formulating extrapolative TKGR as continual learning over streaming snapshots. Under this view, effective extrapolation must jointly handle current dynamics, stable knowledge, and recurring historical evidence. Based on these requirements, we propose History-enhanced Two-Step Continual Learning (HiTS-CL), a backbone-agnostic continual learning framework for extrapolative TKGR. HiTS-CL tracks current dynamics via continual fine-tuning, preserves stable knowledge via multi-teacher adaptive distillation, and retains recurring historical evidence via a selective memory of recent and frequent facts. We integrate HiTS-CL into five representative TKGR backbones and evaluate it on four benchmark datasets. HiTS-CL consistently improves extrapolation accuracy, reduces long-horizon degradation, and outperforms strong continual-learning baselines, including a recent method for temporal knowledge graphs. Source code and data are available at https://github.com/liuyansong98/HiTS-CL. Keywords: Temporal Knowledge Graph; Entity Predictions; Event Forecasting †c-license: by 1. Introduction Temporal Knowledge Graph Reasoning (TKGR) aims to infer missing temporal facts from evolving knowledge graphs represented as quadruples (s,r,o,t)(s,r,o,t) (Mo et al., 2021; Bu et al., 2024; Zhang et al., 2022; Zhang et al., 2026). In extrapolative TKGR, the goal is to predict facts at future timestamps beyond the observed timeline (Jin et al., 2020). This setting is important for applications such as temporal question answering (Saxena et al., 2021; Shang et al., 2022; Jiao et al., 2023; Mavromatis et al., 2022), recommendation (Xiao et al., 2020; Mezni, 2021), information retrieval (Yang et al., 2020), and decision support (Song et al., 2020; Chaturvedi, 2024). (a) (b) Figure 1. (a) Long-horizon performance decay of a fixed-prefix backbone versus HiTS-CL on the test stream (MRR averaged over 100 snapshots). Dashed/solid curves denote the backbone and its HiTS-CL variant. (b) Fixed-prefix training versus continual updating evaluated on the immediately following test snapshot after the training period (snapshot 1001; train: 1–1000). Most existing extrapolative TKGR methods follow a fixed-prefix protocol: they are trained once on an early prefix of the timeline and then applied unchanged to all future timestamps, as in RE-GCN (Li et al., 2021), TANGO (Han et al., 2021), CEN (Li et al., 2022b), TiTer (Haohai et al., 2021), HGLS (Zhang et al., 2023), RETIA (Liu et al., 2023), LogCL (Chen et al., 2023a), TiPNN (Dong et al., 2024), and DiMNet (Dong et al., 2025). We argue that this protocol is fundamentally misaligned with extrapolation. It learns a static predictor from an early prefix, while the target stream is non-stationary and continues to evolve after deployment. As a result, models trained only on early snapshots exhibit clear long-horizon degradation (Figure 1(a)) and can even underperform continually updated models on the first test snapshot immediately after training (Figure 1(b)). This mismatch stems from three challenges. First, temporal knowledge graphs evolve in an open-world manner: new facts continually emerge. Second, temporal dependencies may shift across regimes: fixed-prefix models tend to capture stable knowledge but fail to adapt to transient current dynamics, as illustrated by the immediate performance drop in Figure 1(b). Third, future prediction often depends on recurring historical evidence, such as periodic or high-frequency interaction patterns (Zhu et al., 2021; Chen et al., 2023a; Gastinger et al., 2024; Li et al., 2022a), which must be refreshed online without storing the entire history. These observations motivate a different formulation: extrapolative TKGR should be treated as continual learning over streaming snapshots. Under this view, effective extrapolation must jointly capture current dynamics, stable knowledge, and recurring historical evidence. This setting also differs from prior continual TKG formulations, which typically focus on within-snapshot completion rather than strict next-step forecasting under a no-leakage extrapolation protocol. Based on this view, we propose History-enhanced Two-Step Continual Learning (HiTS-CL), a model-agnostic continual learning framework for extrapolative TKGR. HiTS-CL tracks current dynamics through continual fine-tuning, preserves stable knowledge through multi-teacher adaptive distillation, and retains recurring historical evidence through a selective memory inspired by cache replacement strategies (Megiddo and Modha, 2003). In this way, HiTS-CL explicitly separates and recombines the three predictive ingredients required for extrapolation. We integrate HiTS-CL into five representative TKGR backbones and evaluate it on four benchmark datasets. HiTS-CL consistently improves extrapolation accuracy, reduces long-horizon degradation, and outperforms strong continual-learning baselines as well as a recent continual-learning method for temporal knowledge graphs adapted to our no-leakage extrapolation setting. Our contributions are summarized as follows: • We identify a fundamental limitation of the fixed-prefix protocol for extrapolative TKGR: it relies on a static predictor for a non-stationary forecasting problem, leading to outdated models and long-horizon degradation. • We reformulate extrapolative TKGR as continual learning over streaming snapshots, yielding a setting better aligned with evolving temporal knowledge graph streams. • We propose HiTS-CL, a model-agnostic continual learning framework for extrapolative TKGR, which explicitly separates and recombines current dynamics, stable knowledge, and recurring historical evidence through continual fine-tuning, multi-teacher adaptive distillation, and selective-memory history enhancement. • Experiments across multiple backbones and benchmark datasets show that HiTS-CL consistently improves extrapolation accuracy and outperforms strong baselines. 2. Related Work 2.1. Temporal Knowledge Graph Reasoning Temporal Knowledge Graph Reasoning (TKGR) is commonly studied under interpolation and extrapolation settings (Jin et al., 2020). Given training timestamps [0,T][0,T], interpolation predicts missing facts within the observed range (0<t<T0<t<T), whereas extrapolation predicts facts at future timestamps (t>Tt>T). Extrapolation is generally more challenging and more relevant in practice. Existing methods model temporal evolution through structural and sequential patterns, such as snapshot-based graph encoders and temporal sequence modeling (Li et al., 2021; Li et al., 2022b; Liu et al., 2023; Chen et al., 2023a; Dong et al., 2025). In parallel, recurring and periodic events have also been shown to provide strong signals for temporal forecasting (Zhu et al., 2021; Chen et al., 2023a; Xu et al., 2023; He et al., 2021; Gastinger et al., 2024; Liang et al., 2023; Li et al., 2022a; Zhang et al., 2024b; Zhang et al., 2024a). Despite these advances, most extrapolative TKGR methods still follow a fixed-prefix training protocol: they are trained once on early snapshots and then applied unchanged to future timestamps. As a result, they are not designed to adapt to evolving temporal streams during deployment. Our work differs in treating extrapolative TKGR as continual learning over streaming snapshots. Figure 2. Overview of HiTS-CL: continual fine-tuning captures current dynamics, multi-teacher distillation preserves stable knowledge while incorporating time-varying patterns, and selective-memory history enhancement provides recurring historical evidence. 2.2. Continual Learning and Continual Graph Learning Continual learning (CL) studies how models learn from sequential data while balancing adaptation and knowledge retention (Wang et al., 2024). It is also referred to as lifelong learning (Liu, 2017) or incremental learning (Castro et al., 2018). While CL has been extensively studied on Euclidean data (Wang et al., 2024), extending it to graphs introduces additional challenges due to evolving nodes, edges, and their propagated influence (Tian et al., 2024). Representative graph continual learning approaches include IncDE (Liu et al., 2024), SSRM (Su et al., 2023), and LKGE (Cui et al., 2023). Several works have extended continual learning to temporal knowledge graphs (Chen et al., 2023b; Mirtaheri et al., 2023; Zhang et al., 2025). However, they typically formulate learning within individual snapshots or incremental temporal KG completion settings, rather than next-step forecasting under an extrapolative protocol. In particular, their evaluation settings do not explicitly target streaming prediction where training and validation strictly precede future test snapshots. Among them, DGAR (Zhang et al., 2025) is the closest to our work, as it also studies continual learning for temporal knowledge graphs. However, DGAR focuses on within-snapshot interpolation and delayed task-level evaluation: training, validation, and test facts are split within the same snapshot, and each task is evaluated only after incremental training over all tasks is completed. In contrast, HiTS-CL targets strict streaming extrapolation, where training and validation precede future test snapshots and evaluation is performed immediately after each continual update. More broadly, most continual graph learning benchmarks focus on node or graph classification (Febrinanto et al., 2023), whereas extrapolative TKGR is a temporal link prediction problem with many incremental stages. This makes continual extrapolation in temporal knowledge graphs a distinct and still under-explored setting. 3. Preliminary and Problem Definition 3.1. Extrapolative Temporal Knowledge Graph Reasoning A temporal knowledge graph (TKG) is represented as a sequence of snapshots tt=1T\G_t\_t=1^T. Each snapshot t=(ℰt,ℛ,t)G_t=(E_t,R,Q_t) is a directed multi-relational graph, where ℰtE_t and ℛR denote the entity and relation sets, and t=(s,r,o,t)∣s,o∈ℰt,r∈ℛQ_t=\(s,r,o,t) s,o _t,\ r \ is the set of facts observed at time t. We consider TKGR under extrapolation, where the goal is to predict facts at future timestamps beyond the observed history. Given a query (s,r,?,t)(s,r,?,t), a TKGR model outputs scores over candidate entities in ℰtE_t. We denote the score assigned to a candidate entity o∈ℰto _t by ψ^(s,r,?,t)(o) ψ_(s,r,?,t)(o). Subject prediction is handled by introducing inverse relations, i.e., by predicting (o,r−1,?,t)(o,r^-1,?,t). 3.2. Extrapolative TKGR as Continual Learning Most existing extrapolative TKGR methods follow a fixed-prefix protocol: they are trained on an early prefix of the timeline and then kept unchanged for all future timestamps. This protocol is mismatched to non-stationary temporal streams. We therefore reformulate extrapolative TKGR as continual learning over streaming snapshots. Starting from deployment time t0t_0, we define a sequence of continual learning stages tt=t0+1T−1\T_t\_t=t_0+1^T-1, where (1) t=(trt,vat,tet), _t= (D_tr^t,D_va^t,D_te^t ), trt=t _tr^t=G_t ,vat=t−1,tet=t+1. ,\;D_va^t=G_t-1,\;D_te^t=G_t+1. At stage t, the model is updated on the current snapshot tG_t and evaluated on the next snapshot t+1G_t+1, matching the streaming extrapolation setting without full retraining. We use the previous snapshot t−1G_t-1 for validation for two reasons. First, unlike a within-snapshot hold-out strategy, it preserves the full current snapshot tG_t for training, avoiding potential data insufficiency in the current update step. Second, we empirically find that this choice yields slightly better results across datasets (Section 5.5). 4. Method We propose HiTS-CL, a model-agnostic continual learning framework for extrapolative TKGR. Given a pretrained TKGR backbone, HiTS-CL incrementally adapts it to streaming snapshots in a stage-wise manner, as illustrated in Figure 2. At each stage t, HiTS-CL first performs continual fine-tuning to capture current dynamics, then applies multi-teacher distillation to preserve stable knowledge while incorporating newly acquired time-varying patterns. In addition, it maintains a selective memory of historical facts, updated online by recency and frequency, to provide recurring historical evidence for prediction. 4.1. Two-Step Continual Learning Let fϕ(s,r,t)∈ℝ|ℰt|f_φ(s,r,t) ^|E_t| denote a TKGR backbone parameterized by ϕφ, which outputs logits over candidate entities for a query (s,r,?,t)(s,r,?,t). The score of a candidate entity o∈ℰto _t is denoted by ψ^(s,r,?,t)(o) ψ_(s,r,?,t)(o), i.e., the o-th entry of fϕ(s,r,t)f_φ(s,r,t). Before deployment, we pretrain the backbone on the offline training split and obtain a pretrained teacher fθpref^pre_θ. The parameters θ remain frozen during continual learning and serve as a stable reference for preserving stable knowledge. During streaming, at each stage t, we maintain a fine-tuned teacher fηtftf^ft_ _t and a student fωtstuf^stu_ _t. 4.1.1. Step 1: Continual Fine-Tuning At stage t, we update the fine-tuned teacher using only the newly arrived snapshot tG_t: (2) fηtft=FineTune(fηt−1ft,t).f^ft_ _t=FineTune\! (f^ft_ _t-1,\ G_t ). This step prioritizes plasticity, enabling rapid adaptation to current time-varying patterns. We use the preceding snapshot t−1G_t-1 for early stopping based on MRR, which follows the no-leakage extrapolation protocol and relies only on past data. Further analysis of this validation strategy is provided in Section 5.5. 4.1.2. Step 2: Multi-Teacher Adaptive Distillation Continual fine-tuning improves adaptation to time-varying patterns but may forget stable knowledge acquired during pretraining. We therefore distill from two teachers into a student: the pretrained teacher fθpref^pre_θ provides stable knowledge, while the fine-tuned teacher fηtftf^ft_ _t provides current time-varying knowledge. We introduce adaptivity in three components: student initialization, sample routing, and temperature scaling. Student initialization We estimate teacher reliability on the current snapshot using MRR: (3) mtpre m^pre_t =MRR(fθpre,t), =MRR\! (f^pre_θ,\ G_t ), mtft m^ft_t =MRR(fηtft,t). =MRR\! (f^ft_ _t,\ G_t ). We then compute a reliability weight (4) ρt=mtpremtpre+mtft, _t= m^pre_tm^pre_t+m^ft_t, and initialize the student by reliability-weighted interpolation: (5) ωt−=ρtθ+(1−ρt)ηt. _t^-= _t\,θ+(1- _t)\, _t. This initialization allows the student to start closer to the more reliable teacher on the current stage. Sample routing Different teachers can be more reliable on different instances. We perform distillation on the current-stage training data trt=tD_tr^t=G_t, which reflects the current regime. For each instance (x,y)∈trt(x,y) _tr^t, where x is a query and y is the ground-truth entity index, let (6) ψpre(x)=fθpre(x),ψft(x)=fηtft(x)ψ^pre(x)=f^pre_θ(x), ψ^ft(x)=f^ft_ _t(x) denote the teacher logits. We define the per-sample supervised losses as (7) ℓpre(x,y)=CE(ψpre(x),y),ℓft(x,y)=CE(ψft(x),y). ^pre(x,y)=CE\! (ψ^pre(x),y ),\; ^ft(x,y)=CE\! (ψ^ft(x),y ). We route each sample to the teacher with lower loss: (8) tpre ^pre_t =(x,y)∈trt∣ℓpre(x,y)≤ℓft(x,y), =\(x,y) _tr^t ^pre(x,y)≤ ^ft(x,y)\, tft ^ft_t =(x,y)∈trt∣ℓft(x,y)<ℓpre(x,y). =\(x,y) _tr^t ^ft(x,y)< ^pre(x,y)\. This allows each teacher to supervise the student on the instances for which it is more reliable. Temperature scaling We use a per-sample temperature to reflect teacher confidence. For the routed teacher logits ψ(x)ψ(x), let (9) p(x)=softmax(ψ(x))p(x)=softmax(ψ(x)) and define the entropy (10) H(x)=−∑ipi(x)log(pi(x)+ϵ).H(x)=- _ip_i(x) \! (p_i(x)+ε ). We set (11) τx=α⋅sigmoid(H(x)), _x=α·sigmoid(H(x)), where ϵε is a small constant for numerical stability and α>0α>0 modulates the differentiation among samples. Lower entropy yields smaller τx _x and thus sharper supervision. Distillation loss Let (12) pxpre p^pre_x =softmax(ψpre(x)/τx), =softmax\! (ψ^pre(x)/ _x ), pxft p^ft_x =softmax(ψft(x)/τx), =softmax\! (ψ^ft(x)/ _x ), pxstu p^stu_x =softmax(ψstu(x)/τx), =softmax\! (ψ^stu(x)/ _x ), where (13) ψstu(x)=fωtstu(x).ψ^stu(x)=f^stu_ _t(x). We distill via KL divergence on the routed subsets: (14) ℒdistillpre ^pre_distill =1|tpre|∑(x,y)∈tpreKL(pprex∥pstux), = 1|D^pre_t| _(x,y) ^pre_tKL\! (p^pre_x\,\|\,p^stu_x ), ℒdistillft ^ft_distill =1|tft|∑(x,y)∈tftKL(pftx∥pstux). = 1|D^ft_t| _(x,y) ^ft_tKL\! (p^ft_x\,\|\,p^stu_x ). Finally, we combine the two losses using ρt _t from Equation 4: (15) ℒdistill=ρtℒdistillpre+(1−ρt)ℒdistillft.L_distill= _t\,L^pre_distill+(1- _t)\,L^ft_distill. 4.2. History Enhancement To capture query-relevant recurring patterns, especially periodic and high-frequency events, we maintain a selective memory for each query pair (s,r)(s,r). The memory module is implemented as a cache over historical facts (s,r,o)(s,r,o), where each entry stores two statistics: its most recent occurrence time and its occurrence frequency. Our update strategy is inspired by adaptive replacement ideas (Megiddo and Modha, 2003) and is summarized in Algorithm 1. Algorithm 1 Selective Memory Algorithm Input: capacity C, historical event sequence for (s,r): A=[(o1,t1),(o2,t2),…]A=[(o_1,t_1),(o_2,t_2),…] Output: Cache contents 1 Initialize T1T_1 as LRU, T2T_2 as LFU cache, and B1,B2B_1,B_2 as double-ended queues; p←0p← 0; 2 for each access (oi,ti)(o_i,t_i) in A do /* Cache hit */ 3 if oi∈T1o_i∈ T_1 then 4 Move (oi,ti)(o_i,t_i) from T1T_1 to T2T_2; set freq(oi)←2freq(o_i)← 2; 5 end if 6 else if oi∈T2o_i∈ T_2 then 7 Increase freq(oi)freq(o_i); update timestamp tit_i; 8 end if 9 Return /* Cache miss */ 10 if oi∈B1o_i∈ B_1 then 11 p←min(C,p+max(|B2|/|B1|,1))p← (C,\,p+ (|B_2|/|B_1|,1)); 12 Call Replace(oio_i); 13 Remove oio_i from B1B_1, insert (oi:ti)(o_i:t_i) at the front of T2T_2; set freq(oi)←2freq(o_i)← 2; 14 end if 15 else if oi∈B2o_i∈ B_2 then 16 p←max(0,p−max(|B1|/|B2|,1))p← (0,\,p- (|B_1|/|B_2|,1)); 17 Call Replace(oio_i); 18 Remove oio_i from B2B_2, insert (oi:ti)(o_i:t_i) at the front of T2T_2; set freq(oi)←2freq(o_i)← 2 19 end if 20 else 21 if |T1|+|B1|=C|T_1|+|B_1|=C then 22 if |T1|<C|T_1|<C then 23 Remove item from B1B_1; 24 Call Replace(oio_i); 25 end if 26 else 27 Remove item from T1T_1; 28 end if 29 end if 30 else if |T1|+|T2|+|B1|+|B2|≥C|T_1|+|T_2|+|B_1|+|B_2|≥ C then 31 if |T1|+|T2|+|B1|+|B2|=2C|T_1|+|T_2|+|B_1|+|B_2|=2C then 32 Remove item from B2B_2; 33 end if 34 Call Replace(oio_i); 35 end if 36 Insert (oi:ti)(o_i:t_i) to T1T_1, set freq(oi)←1freq(o_i)← 1; 37 end if 38 end for 39 Function Replace (oio_i): 40 if |T1|≥1|T_1|≥ 1 and ((oi∈B2o_i∈ B_2 and |T1|=p|T_1|=p) or (|T1|>p|T_1|>p)) then 41 Remove item from T1T_1 and insert its key to front of B1B_1; 42 end if 43 else 44 Remove item from T2T_2 and insert its key to front of B2B_2; 45 end if Following (Zhang et al., 2024b), we use a dynamic cache capacity. Let C0C_0 be a base capacity and let NtN_t be the number of distinct cached facts at time t. We set (16) Ct=C0+γNt,C_t=C_0+γ N_t, where γ is a tunable coefficient. This allows the memory size to grow adaptively with the stream. Inference-time re-ranking Given a query (s,r,?,t)(s,r,?,t), we retrieve cached candidates o associated with the same query pair (s,r)(s,r) and compute two priors. Let Δto t^o denote the time gap since the most recent occurrence of (s,r,o)(s,r,o) in memory, and let Δtmax t denote the maximum such gap among the retrieved candidates. We define the recency prior and frequency prior as (17) ψ(s,r,t)time(o)=exp(1−ΔtoΔtmax),ψ^time_(s,r,t)(o)= \! (1- t^o t ), and (18) ψ(s,r,t)freq(o)=log(freq(o)+1),ψ^freq_(s,r,t)(o)= \! (freq(o)+1 ), where freq(o)freq(o) is the occurrence count of (s,r,o)(s,r,o) stored in memory. For candidates not found in memory, both priors are set to zero. The final history-enhanced score is (19) ψ^(s,r,?,t)(o)=ψ(s,r,?,t)(o)+ψ(s,r,t)time(o)+ψ(s,r,t)freq(o), ψ_(s,r,?,t)(o)= _(s,r,?,t)(o)+ψ^time_(s,r,t)(o)+ψ^freq_(s,r,t)(o), where ψ(s,r,?,t)(o) _(s,r,?,t)(o) denotes the student score and ψ^(s,r,?,t)(o) ψ_(s,r,?,t)(o) is used for ranking. 4.3. Training and Inference HiTS-CL consists of an offline pretraining phase followed by continual learning over streaming snapshots. Pretraining follows the standard procedure of the underlying TKGR backbone and produces the pretrained teacher fθpref^pre_θ. At each continual learning stage t, we first update the fine-tuned teacher on the current snapshot tG_t and use t−1G_t-1 for early stopping. We then train the student on tG_t using both prediction supervision and multi-teacher distillation. The overall objective is (20) ℒ=ℒpred+βℒdistill,L=L_pred+β\,L_distill, where β controls the strength of distillation. Both optimization steps use only current or past snapshots, preserving the no-leakage extrapolation protocol. At inference time, we rank entities using the distilled student score and then apply memory-based re-ranking with the recency and frequency priors in Equation 19. In this way, HiTS-CL combines continually updated model parameters for current dynamics and stable knowledge with lightweight historical priors for recurring evidence. Table 1. Statistics of the datasets. All facts are chronologically split into training, validation, and test sets. Dataset Entities Relations Snapshots Train Valid Test Test Snapshots New Entities Granularity ICEWS14 7,218 230 365 27,391 4,514 58,825 231 2,149 24 hours ICEWS18 23,033 256 304 140,714 23,320 304,524 203 5,082 24 hours ICEWS05-15 10,488 251 4,017 138,576 22,959 299,794 2,725 3,289 24 hours GDELT 7,691 240 2,751 683,646 114,076 1,480,683 1,688 1,304 15 mins Table 2. Time-aware filtered MRR and Hits@K on ICEWS14/18, ICEWS05-15, and GDELT. We report each backbone under fixed-prefix training and continual learning variants (+FT, +Replay, +Reg, +HiTS-CL). Model ICEWS14 ICEWS18 ICEWS05-15 GDELT MRR H@1 H@3 H@10 MRR H@1 H@3 H@10 MRR H@1 H@3 H@10 MRR H@1 H@3 H@10 RE-GCN (2021) 33.81 25.66 37.48 49.47 28.41 19.33 32.00 46.23 44.29 34.76 49.07 62.65 18.41 11.56 19.45 31.76 RE-GCN+FT 40.00 30.91 44.61 57.13 31.16 21.48 35.22 50.12 49.75 39.51 55.35 69.18 21.79 13.94 23.56 37.13 RE-GCN+Replay 41.29 32.16 45.86 58.61 32.48 22.53 36.75 51.93 51.64 41.21 57.42 71.31 21.75 13.86 23.46 37.21 RE-GCN+Reg 40.10 31.10 44.55 57.02 31.67 21.75 35.77 51.23 52.38 41.99 58.09 72.12 21.10 13.42 22.72 36.09 RE-GCN+HiTS-CL 43.61 34.61 48.48 60.13 34.34 24.44 38.78 53.52 52.53 42.45 58.18 71.56 25.22 16.51 27.83 42.28 CEN (2022) 30.45 22.81 34.31 44.58 30.41 20.99 34.37 48.85 46.34 36.58 51.50 64.88 19.32 12.12 20.52 33.42 CEN+FT 40.98 31.84 45.80 57.99 32.37 22.56 36.67 51.63 49.41 39.09 55.04 69.02 22.25 14.27 24.09 37.88 CEN+Replay 42.51 32.97 47.76 60.15 33.56 23.38 38.10 53.47 51.80 41.28 57.76 71.68 22.09 14.08 23.89 37.82 CEN+Reg 39.49 30.88 43.86 55.59 32.30 22.44 36.56 51.63 52.55 41.97 58.47 72.61 20.92 13.25 22.47 35.97 CEN+HiTS-CL 43.49 34.45 48.52 60.02 34.23 24.10 38.93 53.87 51.63 41.44 57.31 70.85 23.57 15.20 25.73 40.03 RETIA (2023) 37.69 28.89 42.09 54.13 30.29 20.89 34.19 48.67 46.91 37.06 52.10 65.63 19.13 12.02 20.26 33.06 RETIA+FT 39.93 30.85 44.57 57.04 31.65 21.83 35.79 50.92 49.04 38.75 54.54 68.64 21.40 13.54 23.11 36.79 RETIA+Replay 42.19 32.79 47.04 59.83 33.56 23.38 38.10 53.47 51.65 41.09 57.53 71.62 21.39 13.50 23.06 36.92 RETIA+Reg 41.93 32.58 46.67 59.54 31.72 21.98 35.76 50.81 48.84 38.56 54.30 68.42 21.34 13.51 23.05 36.70 RETIA+HiTS-CL 44.25 35.18 49.13 61.10 34.16 24.31 38.11 53.99 52.12 42.06 57.46 71.47 25.48 16.90 27.96 42.26 LogCL (2024) 39.25 29.14 44.06 59.27 30.81 20.52 34.73 51.45 51.64 41.13 57.57 71.90 22.75 13.85 24.42 40.77 LogCL+FT 43.71 33.00 49.15 64.77 33.20 22.14 37.86 55.25 56.93 45.87 63.74 77.77 23.19 14.01 25.02 41.92 LogCL+Replay 46.56 35.95 52.19 67.13 34.70 23.54 39.58 56.89 59.92 49.14 66.66 79.97 24.37 14.87 26.51 43.69 LogCL+Reg 46.64 35.69 52.40 67.97 33.56 22.14 38.24 56.75 59.72 48.82 66.54 80.01 21.44 12.41 23.07 39.84 LogCL+HiTS-CL 49.01 38.88 54.44 68.55 37.56 26.64 42.54 58.99 60.94 50.40 67.48 80.79 28.54 18.53 31.63 48.50 DiMNet (2025) 33.76 25.07 37.66 50.09 27.21 17.86 30.68 45.85 43.78 33.78 48.97 62.62 19.25 12.00 20.41 33.40 DiMNet+FT 33.55 24.62 37.57 50.68 26.66 17.52 29.96 45.03 46.43 35.75 51.94 66.90 19.76 12.36 21.07 34.28 DiMNet+Replay 37.12 27.98 41.41 54.62 28.74 19.18 32.44 47.79 48.22 37.44 53.95 68.76 20.59 12.86 22.10 35.46 DiMNet+Reg 36.42 27.33 40.46 53.88 29.05 19.38 32.72 48.38 47.35 36.77 52.91 67.52 20.95 13.18 22.54 36.01 DiMNet+HiTS-CL 41.50 32.80 46.03 57.47 32.82 23.32 36.98 51.19 53.08 42.95 58.78 72.02 24.61 15.79 27.18 41.89 5. Experiments 5.1. Experimental Setup 5.1.1. Datasets and Baselines. We evaluate extrapolative TKGR on four widely used benchmarks: ICEWS14, ICEWS18, ICEWS05-15, and GDELT. We use a chronological 30%/5%/65% split for training, validation, and test, deliberately adopting a longer test horizon to study long-horizon performance under streaming deployment. Detailed dataset statistics are provided in Table 1. The “New Entities” column indicates the number of entities that appear exclusively in the test set, and the “Test Snapshots” column reports the number of temporal snapshots in the test set. In our setting, the earliest period is used for offline pretraining, the subsequent period for validation, and the most recent period is treated as a streaming deployment phase, where the model is continually updated and evaluated snapshot by snapshot in chronological order. We instantiate HiTS-CL on five representative TKGR backbones: RE-GCN11 1 https://github.com/Lee-zix/RE-GCN (Li et al., 2021), CEN22 2 https://github.com/Lee-zix/CEN (Li et al., 2022b), RETIA33 3 https://github.com/CGCL-codes/RETIA (Liu et al., 2023), LogCL44 4 https://github.com/WeiChen3690/LogCL (Chen et al., 2023a), and DiMNet55 5 https://github.com/hhdo/DiMNet (Dong et al., 2025). These models span diverse architectures, including snapshot-based GNNs, temporal sequence encoders, and contrastive learning frameworks. We also compare against DGAR (Zhang et al., 2025), a continual learning method originally proposed for temporal interpolation and adapted here to our extrapolation protocol. DGAR mitigates forgetting by combining history-context prompting, diffusion-based historical distribution generation, and hierarchical adaptive replay. Specifically, DGAR follows an interpolation setting because its training, validation, and test facts are drawn from the same snapshot, and each task is evaluated only after completing incremental training over all tasks, rather than immediately under a strict temporal order. (a) (b) (c) (d) (e) Figure 3. MRR degradation trends over time of ICEWS05-15. 5.1.2. Evaluation Metrics. We report standard link prediction metrics, including Mean Reciprocal Rank (MRR) and Hits@K (K∈1,3,10K∈\1,3,10\), under the time-aware filtered setting. For each query (s,r,?,t)(s,r,?,t), we rank all candidate entities and filter out other ground-truth entities that form valid facts at the same timestamp. During evaluation at time t, the model is allowed to access only facts with timestamps earlier than t as historical context. This does not leak future information, since facts at the target timestamp are never used as input for queries at t. Accordingly, as evaluation proceeds chronologically, earlier validation and test snapshots become available history for later predictions, matching the streaming extrapolation setting. 5.1.3. Implementation Details The training pipeline has two phases: (1) pretraining on the initial training set, and (2) continual learning over the subsequent snapshot stream. During testing, snapshots are processed sequentially by time; after inferring on snapshot t, its facts are used as continual learning data for the next step and added to the recurring history memory. Following standard TKGR evaluation, we use a fixed global entity vocabulary constructed from the dataset. The continual learning process is snapshot-based, with early stopping applied based on MRR on the validation snapshot. The early-stopping patience is set to 2. The base capacity C0C_0 and growth factor γ of the selective memory are adopted from (Zhang et al., 2024b) with dataset-specific settings. For the +Reg baseline, the regularization coefficient is set to 0.1. All hyperparameters of the base models are kept consistent with their configurations as reported in their official implementation. The same optimizer and learning rate are used throughout both pretraining and continual learning stages. For knowledge distillation, we set the temperature scaling factor α=2α=2 and the distillation loss weight β=1β=1. All experiments are conducted on a Linux server equipped with 52 CPU cores, 384 GB RAM, and an NVIDIA A40 GPU with 48 GB memory. Source code and data are available at https://github.com/liuyansong98/HiTS-CL 5.2. Main Results Figure 4. Comparison of DGAR and LogCL+HiTS-CL. We instantiate HiTS-CL on five representative TKGR backbones and evaluate them on four benchmarks. Table 2 compares each backbone under (i) the original static training protocol and (i) four continual variants: +FT, +Replay, +Reg, and +HiTS-CL. Here, +FT denotes naive continual fine-tuning on the current snapshot, +Replay jointly trains on the current snapshot and a randomly sampled historical snapshot, +Reg penalizes parameter drift between adjacent stages with an ℓ2 _2 regularizer, and +HiTS-CL applies our full two-step continual learning framework with history enhancement. Overall performance HiTS-CL consistently achieves the best performance across all datasets and backbones. Compared with the strongest adapted baseline, +Replay, it improves relative MRR by 6.0%, 6.4%, 2.8%, and 15.7% on ICEWS14, ICEWS18, ICEWS05-15, and GDELT, respectively. Relative to the original static models, HiTS-CL yields average MRR gains of 27.4%, 17.7%, 16.1%, and 29.1%, showing that handling non-stationarity is critical for long-horizon extrapolation. (a) (b) (c) (d) Figure 5. Fixed-prefix training versus continual updating under the same evaluation snapshot (MRR). Table 3. Ablation study on ICEWS14, ICEWS18, ICEWS05-15 and GDELT. All metrics are time-aware filtered. Model ICEWS14 ICEWS18 ICEWS05-15 GDELT MRR H@1 H@3 H@10 MRR H@1 H@3 H@10 MRR H@1 H@3 H@10 MRR H@1 H@3 H@10 RE-GCN w/o St.1 42.11 33.46 46.61 58.04 33.69 24.01 38.05 52.45 51.23 41.55 56.71 69.28 23.91 15.44 26.36 40.51 RE-GCN w/o St.2 42.47 33.60 47.33 58.74 33.54 23.83 37.91 52.32 51.59 41.51 57.24 70.58 23.09 16.43 27.69 42.03 RE-GCN w/o His. 41.52 32.36 46.19 58.60 32.20 22.36 36.31 51.54 51.19 41.03 56.69 70.46 22.07 14.14 23.85 37.59 RE-GCN+HiTS-CL 43.61 34.61 48.48 60.13 34.34 24.44 38.78 53.52 52.53 42.45 58.18 71.56 25.22 16.51 27.83 42.28 CEN w/o St.1 39.58 31.10 44.33 54.94 31.95 22.20 36.33 50.93 46.80 37.38 52.24 64.22 21.07 13.05 22.93 36.86 CEN w/o St.2 42.89 33.24 47.24 58.94 33.34 23.51 37.79 52.51 50.25 39.98 55.98 69.66 23.43 15.13 25.57 39.74 CEN w/o His. 42.32 33.14 47.35 59.26 33.20 23.04 37.79 53.01 50.74 40.46 56.41 70.23 22.35 14.32 24.21 38.12 CEN+HiTS-CL 43.49 34.45 48.52 60.02 34.23 24.10 38.93 53.87 51.63 41.44 57.31 70.85 23.57 15.20 25.73 40.03 RETIA w/o St.1 43.85 34.77 48.89 60.58 33.46 23.96 37.33 52.50 50.24 41.02 55.67 67.37 25.25 16.71 27.90 41.69 RETIA w/o St.2 42.99 33.94 47.99 59.63 33.45 23.81 37.31 52.79 51.13 40.98 56.74 70.30 25.45 16.79 28.15 42.19 RETIA w/o His. 41.77 32.59 46.42 58.91 32.98 22.99 37.31 52.50 50.85 40.52 56.38 70.53 21.41 13.56 23.08 36.77 RETIA+HiTS-CL 44.25 35.18 49.13 61.10 34.16 24.31 38.11 53.99 52.12 42.06 57.46 71.47 25.48 16.90 27.96 42.26 LogCL w/o St.1 44.63 35.12 49.50 62.73 33.80 23.95 37.91 53.23 51.89 41.62 57.62 71.70 26.54 17.58 29.09 43.99 LogCL w/o St.2 47.25 37.29 52.41 66.62 36.34 25.60 41.19 57.44 59.33 48.75 65.92 79.28 28.05 18.37 31.35 48.14 LogCL w/o His. 46.17 35.54 51.64 66.98 34.91 23.75 39.70 57.08 59.61 48.71 66.43 79.98 24.26 14.78 26.31 48.50 LogCL+HiTS-CL 49.01 38.88 54.44 68.55 37.56 26.64 42.54 58.99 60.94 50.40 67.48 80.79 28.54 18.53 31.63 48.50 DiMNet w/o St.1 41.32 32.65 45.83 57.45 32.70 23.23 36.88 51.03 50.44 40.98 55.78 68.03 24.29 15.63 26.82 41.22 DiMNet w/o St.2 39.04 30.61 43.38 54.53 31.23 22.13 35.16 48.81 51.01 40.95 56.60 69.88 24.20 15.60 26.69 41.09 DiMNet w/o His. 37.23 28.06 41.50 54.72 29.05 19.44 32.79 48.17 49.75 39.21 55.39 69.76 20.46 12.79 21.89 35.51 DiMNet+HiTS-CL 41.50 32.80 46.03 57.47 32.82 23.32 36.98 51.19 53.08 42.95 58.78 72.02 24.61 15.79 27.18 41.89 Why continual adaptation matters Even +FT outperforms static training in nearly all settings, despite suffering from forgetting. This shows that continual adaptation to evolving temporal patterns is already beneficial. However, +FT remains clearly behind +Replay and HiTS-CL, indicating that adaptation alone is insufficient. +Reg is occasionally helpful but lacks consistent gains, suggesting that simple regularization is not enough to balance stability and plasticity under temporal drift. Comparison with DGAR Figure 4 compares HiTS-CL with DGAR (Zhang et al., 2025), a continual method designed for interpolation and adapted here to extrapolation. Although DGAR improves over static TKGR baselines, it remains consistently weaker than standard TKGR backbones equipped with HiTS-CL. For example, LogCL+HiTS-CL surpasses DGAR by 11.5%, 11.4%, 11.9%, and 18.4% MRR on ICEWS14, ICEWS18, ICEWS05-15, and GDELT, respectively. Long-horizon robustness Figure 3 plots MRR over time on ICEWS05-15, with each point averaged over 100 snapshots. Static models show clear performance decay as the horizon grows, whereas HiTS-CL substantially stabilizes this trend and often improves performance over time, indicating stronger robustness to temporal drift. Takeaway. HiTS-CL consistently improves extrapolation accuracy and substantially mitigates long-horizon degradation. Generic continual baselines alleviate part of the decay, but still fall short of HiTS-CL, highlighting the value of jointly modeling current dynamics, stable knowledge, and recurring historical evidence. 5.3. Training Paradigm Comparison We compare continual learning with the traditional fixed-prefix regime by evaluating both on the first snapshot immediately after the training period. Fixed-prefix training For GDELT and ICEWS05-15, we train on snapshots 1–1000, validate on 1002–1101, and test on 1001. For ICEWS14 and ICEWS18, we analogously use 1–100/102–111/101 for train/validation/test. Continual learning For GDELT and ICEWS05-15, we pretrain on 1–900, validate on 901–1000, continually update on 901–1000, and test on 1001. For ICEWS14 and ICEWS18, we analogously use 1–90/91–100/91–100/101 for pretraining/validation/update/test. As shown in Figure 5, continual learning yields a stronger backbone than fixed-prefix training on the same immediately following test snapshot. 5.4. Ablation Study Table 4. Effect of validation strategy on two backbone models (MRR). Using Gt−1G_t-1 for validation consistently performs slightly better than holding out 15% GtG_t. Backbone Validation ICEWS14 ICEWS05-15 GDELT ICEWS18 DiMNet Gt−1G_t-1 41.50 53.08 24.61 32.82 GtG_t (15%) 41.03 52.49 24.36 32.69 RE-GCN Gt−1G_t-1 43.61 52.53 25.22 34.34 GtG_t (15%) 43.29 51.48 25.14 33.43 To quantify the contribution of each component, we conduct ablations on four datasets and multiple TKGR backbones. We evaluate three modules: continual fine-tuning (St.1), multi-teacher distillation (St.2), and history enhancement (His). Table 3 reports evaluation results across all four datasets. Effect of continual fine-tuning (St.1) Removing St.1 causes the largest performance drop across settings. Without continual fine-tuning, the model cannot track current dynamics, and the framework relies primarily on the pretrained teacher, weakening adaptation to the current regime. Effect of multi-teacher distillation (St.2) Removing St.2 also consistently degrades performance. This shows that adapting to recent snapshots alone is insufficient: distillation is needed to combine stable knowledge from the pretrained teacher with current dynamics captured by the fine-tuned teacher, thereby reducing forgetting. Effect of history enhancement (His) Disabling His further reduces performance, with the largest drops on GDELT. This confirms that recurring historical evidence provides complementary signals beyond recent snapshots, especially when observations are sparse or irregular. The magnitude of the drop varies across backbones, suggesting different sensitivity to historical cues. Takeaway. All three components are important: St.1 captures current dynamics, St.2 preserves stable knowledge while reducing forgetting, and His provides up-to-date recurring historical evidence. 5.5. Validation Strategy Analysis Table 5. Inference-time computational cost of the History Enhancement (His) module. We report the average runtime per snapshot and the memory usage of the historical cache on four datasets. ICEWS14 ICEWS05-15 ICEWS18 GDELT Runtime Per snapshot (s) 0.064 0.032 0.408 0.297 Memory usage (MB) 134.18 339.35 535.66 965.93 Figure 6. Runtime comparison (in seconds) between full training and continual learning. In our continual extrapolation setting, the model at stage t is updated using the newly arrived snapshot tG_t while avoiding information leakage from future timestamps. Our default strategy trains on the full tG_t and validates on the previous snapshot t−1G_t-1. A natural alternative is to hold out part of tG_t as a validation set. To examine this design choice, we compare two strategies: (1) validating on t−1G_t-1 (default), and (2) reserving 15%15\% of tG_t for validation while using the remaining 85%85\% for training. Table 4 reports the results on two representative backbones (DiMNet and RE-GCN) across four datasets. Validation on t−1G_t-1 consistently yields slightly better performance than validation on tG_t. This indicates that holding out part of the current snapshot weakens the training signal for learning newly emerging temporal patterns. In contrast, validating on t−1G_t-1 preserves the full training signal and provides a stable selection criterion, as adjacent snapshots are temporally close and typically share similar distributions. Moreover, performance improvements on t−1G_t-1 after learning from tG_t are consistent with backward transfer in continual learning. These results support our default validation strategy. 5.6. Efficiency Analysis 5.6.1. Inference Efficiency During inference, only the distilled student model is used, while the pretrained and fine-tuned teacher models are employed solely for distillation during continual updates. As a result, the inference cost is the same as that of the backbone, with the only additional overhead coming from the History Enhancement module. To quantify this overhead, we measure the average runtime per snapshot and the memory usage of the historical cache on four datasets. The results are summarized in Table 5. The History Enhancement module introduces minimal computational cost (e.g., 0.064s per snapshot on ICEWS14) and moderate memory usage, remaining below 1GB even on GDELT. These findings indicate that HiTS-CL achieves efficient inference while incorporating history-based reasoning, making it practical for large-scale TKGR streams. 5.6.2. Training Efficiency To assess the training efficiency of HiTS-CL, we compare its training time on ICEWS14 using three representative backbones: RE-GCN, LogCL, and DiMNet. This efficiency comparison is conducted under a separate controlled setting, where both methods are evaluated after observing the same first 80% of the timeline. Under the fixed-prefix protocol, each model is trained once on the first 80% of the data. In contrast, HiTS-CL first pretrains on the first 30% and then performs continual learning on the subsequent 50% (from 30% to 80%). Figure 6 compares the overall training time of the original fixed-prefix models and their HiTS-CL variants. On average, HiTS-CL reduces total training time by 15.4%. This gain comes from replacing one expensive full training run with stage-wise updates on smaller increments, which typically require fewer epochs and converge faster. Table 6. Training time breakdown of HiTS-CL (seconds) on ICEWS14, including pretraining, continual fine-tuning, and distillation stages. Model Pretrain Fine-Tune Distillation Overall DiMNet 620 279 492 1,391 LogCL 1,618 736 1,153 3,507 RE-GCN 526 183 527 1,236 Table 7. Case studies illustrating the effect of the History Enhancement module. Entities in bold denote the ground-truth entity. Query (Media_(China), Make_statement, ?, 299) HiTS-CL w/o His. (Top-5) Japan, South_Korea, Kim_Jong-Un, China, North_Korea HiTS-CL (Top-5) China, Japan, South_Korea, Kim_Jong-Un, North_Korea Historical Entities China (freq=11, latest=261), Japan (freq=1, latest=222) To further clarify the computational cost of HiTS-CL, Table 6 reports a detailed breakdown of its training time into three stages: pretraining, continual fine-tuning, and distillation. We observe that pretraining and distillation account for the majority of the total cost, while the continual fine-tuning stage is relatively lightweight across all three backbones. For example, on LogCL, the runtime is 1,618s for pretraining, 736s for continual fine-tuning, and 1,153s for distillation, giving a total of 3,507s. Similar patterns are observed for RE-GCN and DiMNet. Overall, these results show that HiTS-CL is not only effective but also computationally practical for long-term TKGR, with manageable overhead in each stage and lower overall training time than fixed-prefix training. 5.7. Case Study We further present a case study to illustrate how the History Enhancement module improves prediction quality. Table 7 compares the top-ranked candidate entities predicted by HiTS-CL with and without the History Enhancement module. In the example, entities that appear frequently in historical events and have recent occurrences (e.g., China) are promoted to higher ranks after applying the History Enhancement module. This indicates that incorporating simple historical statistics, such as frequency and recency, can effectively guide the model toward temporally consistent predictions. 6. Hyperparameter Sensitivity Analysis (a) (b) (c) (d) Figure 7. Sensitivity analysis of α and β hyper-parameters. In this section, we investigate the impact of two hyperparameters—the temperature scaling factor α and the distillation loss weight β—on model performance using RE-GCN, LogCL, and DiMNet as backbones on the ICEWS14 and GDELT datasets. The results are shown in Figure 7. By adjusting α, the model can amplify or attenuate the differentiation among samples with varying confidence levels during distillation. As shown in Figure 7(a) and 7(c), experimental results on both datasets demonstrate that the model is generally robust across a wide range of α values. However, extremely high or low values can lead to performance degradation. The results for the distillation loss weight β are shown in Figure 7(b) and 7(d). This parameter exhibits different behavior across the datasets: it shows broad robustness on GDELT, but some sensitivity is observed for certain base models on the ICEWS14 dataset. 7. Conclusion We revisit extrapolative temporal knowledge graph reasoning and argue that the prevailing fixed-prefix training paradigm is fundamentally mismatched to non-stationary temporal streams, which leads to substantial long-horizon performance degradation. To address this issue, we formulate extrapolative TKGR as continual learning over streaming snapshots and propose HiTS-CL, a history-enhanced two-step continual learning framework. HiTS-CL captures current dynamics through continual fine-tuning, preserves stable knowledge through multi-teacher adaptive distillation, and incorporates recurring historical evidence through selective memory. Experiments on five TKGR backbones across four benchmarks show that HiTS-CL consistently improves extrapolation accuracy, mitigates long-horizon degradation, and outperforms strong continual-learning baselines as well as a representative continual TKG method under a unified no-leakage extrapolation protocol. These results support continual learning as a practical and effective paradigm for long-running temporal knowledge graph streams. Acknowledgements. This work is supported in part by the National Natural Science Foundation of China (NSFC, Grant Nos. 72571019, 62006005, and 62372054), the National Key Research and Development Program of China (Grant No. 2022YFC3302200), the Ministry of Education Humanities and Social Sciences Project (Grant No. 22YJCZH242), and the Special Fund of the Ministry of Science and Technology of China for Major Scientific Research Facilities and Large-scale Research Instruments (Project: National Network Management Platform System Operation and Support Service). GenAI Usage Disclosure The authors used generative AI tools only for language polishing and grammar checking. All technical ideas, experimental design, implementation, analysis, and conclusions were developed and verified by the authors. References Bu et al. (2024) Y. Bu, Y. Lu, Y. Wang, B. Huang, Y. Tao, and Y. Shi A survey of temporal knowledge graph reasoning. In 2024 7th International Conference on Pattern Recognition and Artificial Intelligence (PRAI), Vol. , p. 657–661. External Links: Document Cited by: §1. Castro et al. (2018) F. M. Castro, M. J. Marín-Jiménez, N. Guil, C. Schmid, and K. Alahari End-to-end incremental learning. In Proceedings of the European conference on computer vision (ECCV), p. 233–248. Cited by: §2.2. Chaturvedi (2024) R. Chaturvedi Temporal knowledge graph extraction and modeling across multiple documents for health risk prediction. In Companion Proceedings of the ACM Web Conference 2024, p. 1182–1185. Cited by: §1. Chen et al. (2023a) W. Chen, H. Wan, Y. Wu, S. Zhao, J. Cheng, Y. Li, and Y. Lin Local-global history-aware contrastive learning for temporal knowledge graph reasoning. arXiv preprint arXiv:2312.01601. Cited by: §1, §1, §2.1, §5.1.1. Chen et al. (2023b) Z. Chen, C. Xu, F. Su, Z. Huang, and Y. Dou Temporal extrapolation and knowledge transfer for lifelong temporal knowledge graph reasoning. In Findings of the Association for Computational Linguistics: EMNLP 2023, p. 6736–6746. Cited by: §2.2. Cui et al. (2023) Y. Cui, Y. Wang, Z. Sun, W. Liu, Y. Jiang, K. Han, and W. Hu Lifelong embedding learning and transfer for growing knowledge graphs. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 37, p. 4217–4224. Cited by: §2.2. Dong et al. (2025) H. Dong, Z. Qiao, Z. Ning, Q. Hao, Y. Du, P. Wang, and Y. Zhou Disentangled multi-span evolutionary network against temporal knowledge graph reasoning. arXiv preprint arXiv:2505.14020. Cited by: §1, §2.1, §5.1.1. Dong et al. (2024) H. Dong, P. Wang, M. Xiao, Z. Ning, P. Wang, and Y. Zhou Temporal inductive path neural network for temporal knowledge graph reasoning. Artificial Intelligence 329, p. 104085. Cited by: §1. Febrinanto et al. (2023) F. G. Febrinanto, F. Xia, K. Moore, C. Thapa, and C. Aggarwal Graph lifelong learning: a survey. IEEE Computational Intelligence Magazine 18 (1), p. 32–51. Cited by: §2.2. Gastinger et al. (2024) J. Gastinger, C. Meilicke, F. Errica, T. Sztyler, A. Schuelke, and H. Stuckenschmidt History repeats itself: a baseline for temporal knowledge graph forecasting. In Proceedings of the Thirty-Third International Joint Conference on Artificial Intelligence, IJCAI ’24. External Links: ISBN 978-1-956792-04-1, Link, Document Cited by: §1, §2.1. Han et al. (2021) Z. Han, Z. Ding, Y. Ma, Y. Gu, and V. Tresp Learning neural ordinary equations for forecasting future links on temporal knowledge graphs. In Proceedings of the 2021 conference on empirical methods in natural language processing (EMNLP), p. 8352–8364. Cited by: §1. Haohai et al. (2021) S. Haohai, Z. Jialun, M. Yunpu, H. Zhen, and K. He TimeTraveler: reinforcement learning for temporal knowledge graph forecasting. In Proceedings of the 2021 conference on empirical methods in natural language processing (EMNLP), Cited by: §1. He et al. (2021) Y. He, P. Zhang, L. Liu, Q. Liang, W. Zhang, and C. Zhang HIP network: historical information passing network for extrapolation reasoning on temporal knowledge graph. In Proceedings of the Thirtieth International Joint Conference on Artificial Intelligence, IJCAI 2021, Virtual Event / Montreal, Canada, 19-27 August 2021, p. 1915–1921. External Links: Link Cited by: §2.1. Jiao et al. (2023) S. Jiao, Z. Zhu, W. Wu, Z. Zuo, J. Qi, W. Wang, G. Zhang, and P. Liu An improving reasoning network for complex question answering over temporal knowledge graphs. Applied Intelligence 53 (7), p. 8195–8208. Cited by: §1. Jin et al. (2020) W. Jin, M. Qu, X. Jin, and X. Ren Recurrent event network: autoregressive structure inferenceover temporal knowledge graphs. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), B. Webber, T. Cohn, Y. He, and Y. Liu (Eds.), Online, p. 6669–6683. External Links: Link, Document Cited by: §1, §2.1. Li et al. (2022a) Y. Li, S. Sun, and J. Zhao TiRGN: time-guided recurrent graph network with local-global historical patterns for temporal knowledge graph reasoning. In Proceedings of the Thirty-First International Joint Conference on Artificial Intelligence, IJCAI-22, L. D. Raedt (Ed.), p. 2152–2158. Note: Main Track External Links: Document, Link Cited by: §1, §2.1. Li et al. (2022b) Z. Li, S. Guan, X. Jin, W. Peng, Y. Lyu, Y. Zhu, L. Bai, W. Li, J. Guo, and X. Cheng Complex evolutional pattern learning for temporal knowledge graph reasoning. In Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 2: Short Papers), S. Muresan, P. Nakov, and A. Villavicencio (Eds.), Dublin, Ireland, p. 290–296. External Links: Link, Document Cited by: §1, §2.1, §5.1.1. Li et al. (2021) Z. Li, X. Jin, W. Li, S. Guan, J. Guo, H. Shen, Y. Wang, and X. Cheng Temporal knowledge graph reasoning based on evolutional representation learning. In Proceedings of the 44th International Conference on Research on Development in Information Retrieval (SIGIR), p. 408–417. Cited by: §1, §2.1, §5.1.1. Liang et al. (2023) K. Liang, L. Meng, M. Liu, Y. Liu, W. Tu, S. Wang, S. Zhou, and X. Liu Learn from relational correlations and periodic events for temporal knowledge graph reasoning. In Proceedings of the 46th international ACM SIGIR conference on research and development in information retrieval, p. 1559–1568. Cited by: §2.1. Liu (2017) B. Liu Lifelong machine learning: a paradigm for continuous learning. Frontiers of Computer Science 11 (3), p. 359–361. Cited by: §2.2. Liu et al. (2024) J. Liu, W. Ke, P. Wang, Z. Shang, J. Gao, G. Li, K. Ji, and Y. Liu Towards continual knowledge graph embedding via incremental distillation. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 38, p. 8759–8768. Cited by: §2.2. Liu et al. (2023) K. Liu, F. Zhao, G. Xu, X. Wang, and H. Jin RETIA: relation-entity twin-interact aggregation for temporal knowledge graph extrapolation. In 2023 IEEE 39th International Conference on Data Engineering (ICDE), p. 1761–1774. Cited by: §1, §2.1, §5.1.1. Mavromatis et al. (2022) C. Mavromatis, P. L. Subramanyam, V. N. Ioannidis, A. Adeshina, P. R. Howard, T. Grinberg, N. Hakim, and G. Karypis Tempoqr: temporal question reasoning over knowledge graphs. In Proceedings of the AAAI conference on artificial intelligence (AAAI), Vol. 36, p. 5825–5833. Cited by: §1. Megiddo and Modha (2003) N. Megiddo and D. S. Modha \arc\: A \self-tuning\, low overhead replacement cache. In 2nd USENIX Conference on File and Storage Technologies (FAST 03), Cited by: §1, §4.2. Mezni (2021) H. Mezni Temporal knowledge graph embedding for effective service recommendation. IEEE Transactions on Services Computing 15 (5), p. 3077–3088. Cited by: §1. Mirtaheri et al. (2023) M. Mirtaheri, M. Rostami, and A. Galstyan History repeats: overcoming catastrophic forgetting for event-centric temporal knowledge graph completion. In Findings of the Association for Computational Linguistics: ACL 2023, A. Rogers, J. Boyd-Graber, and N. Okazaki (Eds.), Toronto, Canada, p. 7740–7755. External Links: Link, Document Cited by: §2.2. Mo et al. (2021) C. Mo, Y. Wang, Y. Jia, and Q. Liao Survey on temporal knowledge graph. In 2021 IEEE Sixth International Conference on Data Science in Cyberspace (DSC), Vol. , p. 294–300. External Links: Document Cited by: §1. Saxena et al. (2021) A. Saxena, S. Chakrabarti, and P. Talukdar Question answering over temporal knowledge graphs. In Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing (IJCNLP), C. Zong, F. Xia, W. Li, and R. Navigli (Eds.), Online, p. 6663–6676. External Links: Link, Document Cited by: §1. Shang et al. (2022) C. Shang, G. Wang, P. Qi, and J. Huang Improving time sensitivity for question answering over temporal knowledge graphs. In Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (ACL), S. Muresan, P. Nakov, and A. Villavicencio (Eds.), Dublin, Ireland, p. 8017–8026. External Links: Link, Document Cited by: §1. Song et al. (2020) F. Song, B. Wang, Y. Tang, and J. Sun Research of medical aided diagnosis system based on temporal knowledge graph. In Proceedings of the Advanced Data Mining and Applications, p. 236–250. Cited by: §1. Su et al. (2023) J. Su, D. Zou, Z. Zhang, and C. Wu Towards robust graph incremental learning on evolving graphs. In International Conference on Machine Learning, p. 32728–32748. Cited by: §2.2. Tian et al. (2024) Z. Tian, D. Zhang, and H. Dai Continual learning on graphs: a survey. arXiv preprint arXiv:2402.06330. Cited by: §2.2. Wang et al. (2024) L. Wang, X. Zhang, H. Su, and J. Zhu A comprehensive survey of continual learning: theory, method and application. IEEE transactions on pattern analysis and machine intelligence 46 (8), p. 5362–5383. Cited by: §2.2. Xiao et al. (2020) C. Xiao, L. Sun, and W. Ji Temporal knowledge graph incremental construction model for recommendation. In Proceedings of the Web and Big Data, p. 352–359. Cited by: §1. Xu et al. (2023) Y. Xu, J. Ou, H. Xu, and L. Fu Temporal knowledge graph reasoning with historical contrastive learning. In Proceedings of the AAAI Conference on Artificial Intelligence (AAAI), Vol. 37, p. 4765–4773. Cited by: §2.1. Yang et al. (2020) C. Yang, W. Li, X. Zhang, R. Zhang, and G. Qi A temporal semantic search system for traditional chinese medicine based on temporal knowledge graphs. In Proceedings of the Semantic Technology, p. 13–20. Cited by: §1. Zhang et al. (2022) F. Zhang, Z. Zhang, X. Ao, F. Zhuang, Y. Xu, and Q. He Along the time: timeline-traced embedding for temporal knowledge graph completion. In Proceedings of the 31st ACM international conference on information & knowledge management, p. 2529–2538. Cited by: §1. Zhang et al. (2024a) F. Zhang, Z. Zhang, F. Zhuang, Z. Zhang, J. Zhou, and D. Wang Multi-view temporal knowledge graph reasoning. In Proceedings of the 33rd ACM International Conference on Information and Knowledge Management, p. 4263–4267. Cited by: §2.1. Zhang et al. (2024b) F. Zhang, Z. Zhang, F. Zhuang, Y. Zhao, D. Wang, and H. Zheng Temporal knowledge graph reasoning with dynamic memory enhancement. IEEE Transactions on Knowledge and Data Engineering 36 (11), p. 7115–7128. Cited by: §2.1, §4.2, §5.1.3. Zhang et al. (2026) F. Zhang, F. Zhuang, Z. Zhang, and P. Zhao Temporal knowledge graph reasoning via multi-granularity knowledge refinement. Front. Comput. Sci. 20 (9). External Links: ISSN 2095-2228, Link, Document Cited by: §1. Zhang et al. (2023) M. Zhang, Y. Xia, Q. Liu, S. Wu, and L. Wang Learning long-and short-term representations for temporal knowledge graph reasoning. In Proceedings of the International World Wide Web Conferences (W), p. 2412–2422. Cited by: §1. Zhang et al. (2025) Z. Zhang, W. Chen, Y. Lin, and H. Wan A generative adaptive replay continual learning model for temporal knowledge graph reasoning. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), W. Che, J. Nabende, E. Shutova, and M. T. Pilehvar (Eds.), Vienna, Austria, p. 10964–10977. External Links: Link, Document, ISBN 979-8-89176-251-0 Cited by: §2.2, §5.1.1, §5.2. Zhu et al. (2021) C. Zhu, M. Chen, C. Fan, G. Cheng, and Y. Zhang Learning from history: modeling temporal knowledge graphs with sequential copy-generation networks. In Proceedings of the AAAI conference on artificial intelligence (AAAI), Vol. 35, p. 4732–4740. Cited by: §1, §2.1.