时序知识图谱问答(TKGQA)研究生科研入门深度教程

本文面向初次接触 TKGQA 的研究生,系统梳理从静态 KGQA 到时序场景的演进、主流数据集与方法、最新 LLM/RAG 范式,并提供可直接动手的 PyTorch / HuggingFace 代码示例与参考文献清单。读完之后,你应该能够独立选题、复现 baseline 并定位前沿创新点。

1. 引言:为什么需要 TKGQA?

知识图谱(Knowledge Graph,KG)以三元组 (subject, relation, object) 形式刻画客观世界事实,被广泛用于搜索引擎、推荐系统、对话机器人。然而世界并非静态:奥巴马只在 2009–2017 担任美国总统,梅西在 2021 转会 PSG,在 2023 又加盟迈阿密国际。这些事实带有时间作用域(temporal scope),只有引入时间维度才能正确回答"2014 年世界杯期间法国总统是谁?"这类问题。

时序知识图谱(Temporal Knowledge Graph,TKG)在三元组基础上增加时间维度,形成四元组 (s, r, o, t) 或带区间的 (s, r, o, [t_start, t_end])。时序知识图谱问答(Temporal KGQA, TKGQA)即在 TKG 上回答含时间约束的自然语言问题,是 KBQA(Knowledge Base Question Answering)在时间维度上的关键扩展。Saxena 等人 (ACL 2021) 在提出大规模基准 CronQuestions 时直言:"Temporal Knowledge Graphs (Temporal KGs) extend regular Knowledge Graphs by providing temporal scopes (start and end times) on each edge in the KG. ... QA over Temporal KGs (Temporal KGQA) is a relatively unexplored area." 这一论断至今仍是该方向的起点。

TKGQA 兼具两类难点:(1) 时间表达本身的异质性(年份、月份、日期、相对表述如 "during WWII"、"three years after");(2) 时间逻辑的复杂性(before/after、first/last、overlap、aggregation)。这使得仅靠静态 KGQA 模型(如 EmbedKGQA)远不能解决问题,直接套用大模型(LLM)也常因时间幻觉而失败。本教程将沿着 「概念 → 数据 → 模型 → LLM/RAG → 代码 → 挑战」 的脉络展开。

2. 背景与基础概念

2.1 知识图谱(KG)

定义:知识图谱是一个有向多重图 $G = (\mathcal{E}, \mathcal{R}, \mathcal{F})$,其中 $\mathcal{E}$ 是实体集、$\mathcal{R}$ 是关系集、$\mathcal{F} \subseteq \mathcal{E} \times \mathcal{R} \times \mathcal{E}$ 是事实(三元组)集合。如 (Barack_Obama, born_in, Honolulu)。代表性 KG 有 Freebase、Wikidata、DBpedia、YAGO、NELL。

2.2 时序知识图谱(TKG)

TKG 引入时间集合 $\mathcal{T}$,事实集合为 $\mathcal{F} \subseteq \mathcal{E} \times \mathcal{R} \times \mathcal{E} \times \mathcal{T}$。常见两种粒度:

• 时间戳型(time-point): $(s, r, o, t)$,典型如 ICEWS、GDELT 中的政治事件,精确到天。
• 时间区间型(time-interval): $(s, r, o, [t_{\text{start}}, t_{\text{end}}])$,例如 (Barack_Obama, position_held, President_of_US, [2009-01-20, 2017-01-20]),典型如 Wikidata、YAGO11k。

2.3 四元组的两种表示与互转

区间型可拆为两条事实 $(s, r, o, t_{\text{start}})$ 与 $(s, r, o, t_{\text{end}})$,或离散化为 $\{(s,r,o,t) : t \in [t_{\text{start}}, t_{\text{end}}]\}$,后者用于 TComplEx 等张量分解模型。时间粒度选择(年 / 月 / 日)会显著影响时间戳数量 $|\mathcal{T}|$,进而影响嵌入参数量与数据稀疏性。

2.4 静态 KGQA vs TKGQA

2.5 TKGQA 的形式化定义

给定 TKG $G=(\mathcal{E},\mathcal{R},\mathcal{T},\mathcal{F})$ 与自然语言问题 $q$,TKGQA 任务是学习函数 $f_\theta: (q, G) \rightarrow a$,其中答案 $a \in \mathcal{E} \cup \mathcal{T}$。训练目标通常采用交叉熵:

$$\mathcal{L} = -\sum_{(q,a^*) \in \mathcal{D}} \log \frac{\exp(\phi(q, a^*))}{\sum_{a' \in \mathcal{E} \cup \mathcal{T}} \exp(\phi(q, a'))}$$

其中 $\phi(q, a)$ 是问题–候选答案的打分函数,具体形式因模型而异(见第 4 节)。

2.6 问题类型分类(taxonomy)

综合 TempQuestions (Jia et al., 2018)、CronQuestions (Saxena et al., 2021) 与 TKGQA 综述 (Su et al., arXiv:2406.14191) 的划分,TKGQA 问题主要分为以下几类:

1. Simple Time(简单时间问答): 答案是时间。例:"When did Obama become president?"
2. Simple Entity(简单实体问答): 给定时间约束,答案是实体。例:"Who was the US president in 2010?"
3. Before/After(前后推理): 例:"Who was president before Obama?"
4. First/Last(首次/最后): 例:"When did Messi win his first Ballon d'Or?"
5. Time Join(时间交叉): 例:"Who was UN Secretary-General when Obama was president?"——两个事实的时间区间需要 overlap。
6. Ordinal / Duration(序数与时长): 例:"How long was Obama president?"
7. Implicit Temporal(隐式时间): 时间不出现在问句中,需从背景推断。例:"Who scored in the WWII victory parade?"

CronQuestions 把前两类标为 Simple,后续 Before/After、First/Last、Time Join 三类合称 Complex。MultiTQ 引入了 Multi-granularity(粒度)与 Multi-constraint(多约束)两条正交维度。

2.7 应用场景

• 时事问答与新闻助手: 用户问"上次美联储加息是什么时候?",需要时序敏感答案。
• 金融与法律风控: "公司 A 在 2020-2022 间是否被某监管机构处罚?"——区间重叠推理。
• 医疗病程分析: 病历是天然的时序图,询问"患者在用药 X 后多久出现并发症?"。
• 事件预测与情报分析: 基于 ICEWS / GDELT 的多步时序推理。

3. 数据集与基准 Benchmark

3.1 CronQuestions (Saxena, Chakrabarti, Talukdar, ACL 2021)

CronQuestions 是迄今规模最大、最常被引用的 TKGQA 基准,基于 Wikidata 构建,通过模板自动生成。原文 §3.1 明确指出 "This resulted in a KG with 323k facts, 125k entities and 203 relations... The final Temporal KG consisted of 328k facts out of which 5k are event-facts",因此精确数字为:

• 底层 Wikidata TKG: 125,000 个实体、203 个关系、约 1,700 个时间戳(以年为粒度,从 1987 起)、328,000 条事实四元组 = 323k 常规事实 + 5k 事件型事实。
• 问答规模: 410,000 条问答对,按 350K/30K/30K 划分为训练/验证/测试。
• 问题模板五类: Simple Time、Simple Entity、Before/After、First/Last、Time Join。
• 答案类型精确分布(Saxena et al., Table 4): Entity Answer 训练 225,672 / 验证 19,362 / 测试 19,524;Time Answer 训练 124,328 / 验证 10,638 / 测试 10,476。

每类问题的训练样本数也由 Table 4 给出:First/Last 最多(118,556),其次 Simple Entity(90,651)、Simple Time(61,471)、Time Join(55,453)、Before/After(23,869)。

CronQuestions 同时公布了 incomplete TKG 设定(随机抹去 20%/33%/50% 的时间戳),用于测试模型在不完整 TKG 下的稳健性。后续 SubGTR 进一步从中过滤出 Complex-CronQuestions,聚焦真正需要时间推理的子集。

3.2 TimeQuestions (Jia et al., CIKM 2021)

EXAQT 同期发布的基准,合并自 8 个 KGQA 数据集(LC-QuAD 2.0、QALD、ComQA、WebQuestions 等),共 16,181 条真实人工/众包问句(后续版本扩至 16,859),链接到 Wikidata,按 60/20/20 划分 9,708/3,236/3,237。问题标注 4 类:Explicit、Implicit、Temporal Answer、Ordinal。

3.3 TempQuestions 与 TEQUILA (Jia et al., 2018)

TempQuestions 是最早的 TKGQA 基准(WWW 2018 Companion),含 1,271 条问题,从 Free917、WebQuestions、ComplexQuestions 中抽取的时间相关子集,链接到 Freebase。TEQUILA(CIKM 2018)是同组的时间约束问句重写方法,常被作为传统基线。

3.4 MultiTQ (Chen, Liao, Zhao, ACL 2023)

MultiTQ 解决 CronQuestions "粒度单一(年)" 的局限,基于 ICEWS05-15 构建:

• 底层 TKG: 10,488 实体、251 关系、4,017 个时间戳(以天为粒度,2005-2015 共 11 年)、约 480,000 条四元组。
• 问答规模: 约 500,000 问答对,按 ~8:1:1 划分(训练 386,787、测试 54,584;开发集行和约 57,979——原表格中印刷的 587,979 为已知排版错误)。
• 三种时间粒度: day(145,743)、month(83,635)、year(64,187),让模型学会跨粒度推理。
• 问题类型六类: Single-Equal、Single-Before/After、Single-First/Last、Multiple-Equal、Multiple-After-First、Multiple-Before-Last,覆盖单约束和多约束。

3.5 ComplexTempQA 与 TimelineKGQA

ComplexTempQA(Gruber et al., EMNLP 2025,arXiv 2406.04866 首发于 2024-06):基于 Wikipedia + Wikidata,涵盖 1987–2023 共 36 年,规模高达 1 亿+ 问答对,引入 attribute / comparison / counting 三大类,每类围绕 event / entity / time period 展开。其超大规模主要用于 LLM 评测与时间盲点检测,而非端到端训练。

TimelineKGQA(Sun et al., WWW 2025 Companion,arXiv 2501.04343):提出一个面向任意 TKG 的"通用 QA 生成器",基于 timeline-context 关系框架,系统覆盖 Allen 的 13 种时序关系、集合操作、duration、ranking。作者直言"CronQuestion ... lacks temporal aggregation questions ... current TKG embedding-based QA methods have already achieved Hits@1 metrics well above 0.9",意在缓解榜单饱和。

3.6 底层 TKG:ICEWS、GDELT、YAGO

这些虽是 TKG 补全(link prediction)数据集,但常作为 TKGQA 的底层图被引用:

• ICEWS14:7,128 实体、230 关系、365 天时间戳、约 90,730 事实(标准 Goel et al. 划分:训练 72,826 / 验证 8,941 / 测试 8,963)。
• ICEWS05-15:10,488 实体、251 关系、4,017 天时间戳、约 461,329 事实(MultiTQ 用的就是此版本)。
• GDELT:粒度更细,常用于 TKG forecasting;问句基准较少。
• YAGO15k / YAGO11k:时间区间型,常用于 TComplEx、TeRo 评测。

3.7 评估指标

由于 TKGQA 答案空间是 $\mathcal{E} \cup \mathcal{T}$,通常采用排名指标:

$$\text{Hits@k} = \frac{1}{|\mathcal{D}|}\sum_{i=1}^{|\mathcal{D}|}\mathbb{1}[\text{rank}_i \leq k],\qquad \text{MRR}=\frac{1}{|\mathcal{D}|}\sum_{i=1}^{|\mathcal{D}|}\frac{1}{\text{rank}_i}$$

当答案是字符串(LLM 生成)时,辅以 Exact Match (EM) 和 token-level F1。注意:Hits@1 与 EM 数值上可能不等,因为 LLM 的输出需要先经过实体规范化。

3.8 数据集对比表

4. 传统主流方法

TKGQA 模型大致分两条技术路线:TKG 嵌入路线(IR-based)把问答视作链路预测,在嵌入空间排序候选答案;语义解析路线(SP-based)把问题翻译为可执行的逻辑表达式(SPARQL、KoPL)。Su 等 (2024) 的综述把现有工作划分为这两大类。

4.1 TKG 嵌入族:TComplEx → TNTComplEx → TeRo → ChronoR → TeLM

ComplEx(Trouillon et al., ICML 2016)把每个实体/关系映射到复向量 $\mathbf{e}, \mathbf{r} \in \mathbb{C}^d$,三元组打分为 $\phi(s,r,o)=\text{Re}(\langle \mathbf{e}_s, \mathbf{r}, \overline{\mathbf{e}_o}\rangle)$,擅长建模非对称关系。

TComplEx / TNTComplEx(Lacroix, Obozinski, Usunier, ICLR 2020)把 ComplEx 推广为4 阶张量分解。设时间戳嵌入 $\mathbf{t}_l \in \mathbb{C}^d$,TComplEx 打分函数为:

$$\phi(s,r,o,t)=\text{Re}\big(\langle \mathbf{e}_s,\; \mathbf{r} \odot \mathbf{t}_l,\; \overline{\mathbf{e}_o}\rangle\big)$$

其中 $\odot$ 为 Hadamard 积,等价于让时间戳"调制"关系。TNTComplEx 进一步把张量分成"时序"与"非时序"两部分相加,适合 Wikidata 这类异质 KB(因为 "Malia 是 Obama 的女儿" 永远成立,而 "Obama 担任总统" 只在 2009–2017 成立)。

正则项采用 nuclear 4-norm 的变分形式 $\Omega_4$,Lacroix 等给出:

$$\Omega_4(\mathbf{E},\mathbf{R},\mathbf{T})=\frac{1}{4}\sum_i\|\mathbf{e}_i\|_4^4+\frac{1}{4}\sum_j\|\mathbf{r}_j\|_4^4+\frac{1}{4}\sum_l\|\mathbf{t}_l\|_4^4$$

并附加时间相邻嵌入的平滑项 $\sum_l \|\mathbf{t}_{l+1}-\mathbf{t}_l\|^p$。

TeRo(Xu et al., COLING 2020)将时间作用建模为复空间中的旋转:实体嵌入 $\mathbf{e}_{s,t}=\mathbf{e}_s \circ e^{i\theta_t}$,关系打分为 $\phi=-\|\mathbf{e}_{s,t}+\mathbf{r}-\overline{\mathbf{e}_{o,t}}\|$。对于时间区间事实,关系被表示为一对 dual complex embedding 处理开始/结束。

ChronoR(Sadeghian et al., AAAI 2021)进一步把 (relation, time) 看作 $k$ 维旋转 + 缩放: $\phi(s,r,o,t)=\langle \mathbf{Q}_{r,t}\mathbf{e}_s,\mathbf{e}_o\rangle$,$\mathbf{Q}_{r,t}\in SO(k)$。

TeLM(Xu et al., NAACL 2021)采用 multivector embedding(几何代数中的 multi-vector),做 4 阶张量分解并引入线性时间正则,提升 ICEWS14/ICEWS05-15/YAGO15k 上的 MRR。

4.2 CronKGQA(Saxena et al., ACL 2021):TKGQA 的 first principle 基线

CronKGQA 把 TKGQA 视作带问题约束的链路预测。核心思想:用 BERT/DistilBERT 编码问题得到 $\mathbf{q}\in\mathbb{R}^d$,作为"虚拟关系"嵌入,然后调用 TComplEx 打分函数预测实体或时间。

实体打分:

$$\text{score}_E(o\mid q, s)=\text{Re}\big(\langle \mathbf{e}_s,\; \mathbf{q} \odot \mathbf{t},\; \overline{\mathbf{e}_o}\rangle\big)$$

时间打分将时间槽换到候选位置。损失函数为对 $|\mathcal{E}|+|\mathcal{T}|$ 候选的交叉熵。

在 CronQuestions 测试集上,CronKGQA 取得 Hits@1 总体 0.647(Simple 0.987 / Complex 0.392),Hits@10 总体 0.884,显示其能轻松解决简单问句但难以处理复杂时间逻辑。

4.3 TempoQR(Mavromatis et al., AAAI 2022):上下文–实体–时间三模块

TempoQR 指出 CronKGQA 对"Which movie won Best Picture after The Godfather?"这类隐式时间问句无能为力,提出三个专用模块:

1. Context-aware: BERT 编码 [CLS] + 问句,得到 token 表示。
2. Entity-aware: 将问句中提到的实体 (annotated entity) 的 TComplEx 嵌入注入 token 序列。
3. Time-aware: 推断问句对应的时间范围 $[t_1, t_2]$——hard 监督版从 TKG 中直接检索实体的时间区间,soft 监督版通过链路预测推断,因此更通用。

三种嵌入拼接后过 $\ell$ 层 Transformer encoder,输出再以 TComplEx 打分。TempoQR-Hard 在 CronQuestions 复杂问句上 Hits@1 达 0.864,相比 CronKGQA 复杂问句的 0.392 提升 47.2 个百分点。原论文摘要中提到的 "25–45 percentage points" 是相对若干基线(CronKGQA、EaE、EntityQR 等)取的平均区间,并非单一对照值。

4.4 TMA 与 TSQA:增强时间敏感性

TMA(Liu et al., ICASSP 2023):提取问题中与候选三元组(SPO)相关的辅助信息,用三种 token-level attention(question–subject、question–predicate、question–object)进行多路融合,再经 gating 加权与 TComplEx 嵌入相加。

TSQA(Shang et al., ACL Findings 2022):提出时间估计模块(time estimation)推断隐含时间,并引入对比学习(contrastive loss)增强对 "before/after/first/last" 等关系词的敏感度。CronQuestions 上 Hits@1 总体 0.831,复杂问句 0.713。

4.5 SubGTR(Chen et al., KBS 2022)

SubGTR(Subgraph Temporal Reasoning)的洞察是人类回答复杂时序问题时先做隐式知识抽取、再做事实检索、最后做逻辑推理。模型相应包含三个模块:

1. Implicit knowledge extraction: 用 TKG 背景知识重写问题,把隐含时间约束显式化。
2. Relevant facts search: 检索候选子图并初评分。
3. Subgraph logic reasoning: 量化时间约束,套用 before/after/first/last 等时序逻辑算子做过滤。

SubGTR 同时贡献了 Complex-CronQuestions 子集(过滤掉模板里时间和实体强耦合的"伪时序"问句),被后续多数工作采用为复杂问句的真实评测。

4.6 EXAQT(Jia et al., CIKM 2021):面向 TimeQuestions 的两阶段管线

EXAQT 处理的是真实人类问题(TimeQuestions),管线设计与 CronKGQA 截然不同:

1. 阶段 1(高召回): 用 Group Steiner Tree 在 Wikidata 上抽取问题相关紧凑子图,再用 fine-tuned BERT 把时间相关事实(temporal facts)补回子图。
2. 阶段 2(高精度): 在子图上跑 R-GCN,节点初始化为 Wikipedia2Vec + 时间戳编码 + temporal signal + 时间感知实体嵌入,attention 加权聚合时间关系。

EXAQT 是首个端到端复杂时序 QA 系统,被 TimeQuestions 后续工作普遍作为强基线。

4.7 TwiRGCN(Sharma et al., EACL Findings 2023)

TwiRGCN 假设不是所有边对回答时序问题同等重要,核心是时序加权图卷积:对每条边 $(s,r,o,t)$,根据其时间 $t$ 与问题时间约束 $t_q$ 的距离计算注意力权重 $\alpha(t, t_q)$,在 R-GCN 消息传播时加权。它还引入 answer gating(对实体/时间两类候选差异化处理)。在 TimeQuestions 上显著超越 EXAQT,设计简洁是其卖点。

4.8 语义解析路线与对比

语义解析(SP)路线把问题 $q$ 翻译为可执行逻辑形式 $\lambda$(SPARQL / KoPL / λ-calculus),交给 KG 引擎执行。代表工作有 Ding et al. (EMNLP 2022) 的 "Semantic Framework based Query Generation"。优点是显式表达时间算子(BEFORE、OVERLAP 等),可解释性强;缺点是依赖标注的逻辑形式,且 SPARQL 不易扩展时间算子。Prog-TQA(见第 5.3 节)用 LLM + KoPL 复兴了此路线。

5. LLM 与 RAG 时代的 TKGQA(2023-2025)

5.1 直接 prompting LLM 的局限

多项研究(Chu et al. 2023 的 TimeBench、GenTKGQA 的 baseline 实验)发现,即使 ChatGPT / GPT-4 也存在时间幻觉(temporal hallucination):模型常给出错误年份、混淆任期、错过 before/after 边界。Gao 等(Findings of ACL 2024,GenTKGQA)在论文 §5.2 中明确指出 "ChatGPT cannot answer temporal questions directly",其结果表显示无 TKG 上下文的 ChatGPT 在 MultiTQ 上 Hits@1 仅 0.102,远低于经典 CronKGQA(0.279)。原因有三:

• 预训练语料中长尾时间事件覆盖不足;
• LLM 缺乏显式时间区间比较算子;
• 知识截止日期后的事实无法更新。

因此当前主流是 LLM + TKG 检索/嵌入混合,即典型的 KG-RAG 范式。

5.2 GenTKGQA(Gao et al., Findings of ACL 2024)

GenTKGQA 是首个面向 TKGQA 的两阶段生成式框架:

1. Subgraph Retrieval: 利用 LLM 自身的语义能力,从问题中挖掘时间约束与结构链(structural links),把搜索空间在时间和结构两个维度上同时收窄。
2. Answer Generation: 把检索到的相关事实通过 temporal GNN 编码为虚拟知识指示符 token (virtual indicator tokens),与原 prompt 拼接,送入 LLM 做 instruction tuning 输出答案。

形式上输入序列为 $S = V : I : Q : A$,其中 $V$ 是虚拟 token、$I$ 是 instruction、$Q$ 是问题、$A$ 是答案。GenTKGQA 在 CronQuestions 上达 Hits@1 0.978(简单 0.999、复杂 0.962),是目前 CronQuestions 公开榜单上最强方法之一。

5.3 Prog-TQA(Chen et al., LREC-COLING 2024 + ACL 2024 版)

Prog-TQA 复兴语义解析路线,但解析器换成 LLM。核心贡献:

• 扩展 KoPL(Knowledge-oriented Programming Language): 系统设计 before / after / first / last / overlap 等专用时间算子,使得单条时间约束在 KoPL 中只需一个算子,而 SPARQL 需多 clause。
• In-context learning 起草 + Linking 完善: LLM 用 few-shot 生成 KoPL 程序草稿,再由 linking 模块用 BERT 把实体/时间/关系绑定到 TKG 词表,最后执行得到答案。
• Self-improvement bootstrap: 自动识别错误程序,生成修正版,收集正确程序作为新训练数据迭代 fine-tune LLM。

Chen 等(arXiv:2404.01720,§Introduction)写道 "It achieves up to 50.4% improvement overall at Hits@1 on MultiTQ and 3.5% for complex questions at Hits@1 on CronQuestions",验证了显式逻辑形式在多约束下的优势。

5.4 ARI(Chen et al., ACL 2024):基于建构主义的抽象推理归纳

ARI(Abstract Reasoning Induction)受 Piaget 建构主义启发,把时间推理切成两阶段:

1. Knowledge-agnostic 阶段: LLM 仅选择"下一步该做什么"(检索 / 比较 / 排序 / 聚合等抽象方法),不接触具体事实。
2. Knowledge-based 阶段: 在具体 TKG 上执行相应动作得到事实。

这种解耦减少了 LLM 把抽象推理"塌缩"为记忆的现象。ARI 进一步使 LLM 从历史正确/错误样例中自主归纳新方法。在两个 TKGQA 数据集上分别取得 29.7% 和 9.27% 的相对增益。代码开源:czy1999/ARI-QA。

5.5 TimeR⁴(Qian et al., EMNLP 2024):Retrieve–Rewrite–Retrieve–Rerank

TimeR⁴ 是当前 MultiTQ 上的强基线,框架四步:

1. Retrieve 1: 用 off-the-shelf SentenceBERT 从 TKG 取出与问题语义相关的事实。
2. Rewrite: 利用 OpenAI gpt-3.5-turbo-0125 把含模糊时间(如 "after Obama's term")的问句重写为带显式时间约束的问句。
3. Retrieve 2 + Rerank: 用 fine-tuned SentenceBERT(time-aware contrastive loss,10 epochs)做时间感知重排序。
4. Reasoning: 把 top-n 事实塞入 LLaMA2-Chat-7B(经 2 epochs 指令微调)生成最终答案。

Qian 等(EMNLP 2024,ACL Anthology pp. 6942–6952)报告 "Our approach achieves great improvements, with relative gains of 47.8% and 22.5% on two datasets [MultiTQ and TimeQuestions]"。具体数值:MultiTQ Hits@1 0.728(Time 类别高达 0.945),TimeQuestions Hits@1 0.781。

5.6 KG-RAG 与子图检索通用范式

把 TKGQA 当作检索增强生成(RAG)问题是 2024 年后的主流。一般模板:

1. 问题分解: LLM 用 CoT 把复杂问句拆为多个原子子查询(每个对应一个 TKG 检索 / 时间算子)。
2. 子图检索: 基于实体链接 + 关系类型 + 时间窗口三重过滤,召回最多 N(常用 15-20)条相关四元组。
3. 提示拼装: 把检索结果按 "(s, r, o, t)" 列表化为上下文,与问题一起送 LLM。
4. 答案规范化: 将 LLM 输出与 TKG 实体词表对齐,计算 Hits@k / EM。

这种范式可与 ReAct、Tool-use 框架结合:(Thought → Action: search_TKG(Obama, position_held, ?) → Observation → Thought → ...)。Yao 等的 ReAct 提示模板在 ARI / Prog-TQA 中得到不同变体。

5.7 LLM-TKGQA 方法横向对比

6. 代码示例(可直接运行的 minimal 实现)

6.1 加载并预处理 CronQuestions

CronQuestions 原始数据为 pickle 格式(data_v2.zip),每条样本含 question / template / answers / entities / time。下面示例使用 HuggingFace datasets 库式接口:

# 安装:pip install datasets pandas
import pickle, json, os
from pathlib import Path
from collections import Counter

DATA_DIR = Path("./CronQuestions/data")  # 解压后路径

def load_split(split: str):
    """加载 CronQuestions 一个 split,返回 list[dict]。"""
    with open(DATA_DIR / "questions" / f"{split}.pickle", "rb") as f:
        data = pickle.load(f)
    # 每条 record 至少包含:question, answers, entities, times, template, type
    return data

train = load_split("train")
test  = load_split("test")
print(f"训练集大小: {len(train)},测试集大小: {len(test)}")

# 查看一条样本
sample = train[0]
print(json.dumps({k: str(v)[:80] for k, v in sample.items()},
                 ensure_ascii=False, indent=2))

# 统计问题类型分布(对应原论文 Table 4)
type_dist = Counter(r["type"] for r in train)
for t, c in type_dist.most_common():
    print(f"{t:20s}: {c}")
# 期望输出大致(精确值来自原论文 Table 4):
# first_last     : 118556
# simple_entity  :  90651
# simple_time    :  61471
# time_join      :  55453
# before_after   :  23869

加载底层 Wikidata TKG(用于构建答案空间):

def load_tkg(path):
    """读入 tab 分隔的 (s, r, o, t_start, t_end) 文件。"""
    facts = []
    with open(path, "r", encoding="utf-8") as f:
        for line in f:
            parts = line.rstrip("\n").split("\t")
            s, r, o, ts, te = parts[:5]
            facts.append((s, r, o, ts, te))
    return facts

tkg = load_tkg(DATA_DIR / "wikidata_big" / "kg" / "full.txt")
entities = sorted({s for s,_,_,_,_ in tkg} | {o for _,_,o,_,_ in tkg})
relations = sorted({r for _,r,_,_,_ in tkg})
times = sorted({t for *_, ts, te in tkg for t in (ts, te) if t.isdigit()})
print(f"|E|={len(entities)}, |R|={len(relations)}, |T|={len(times)}, |F|={len(tkg)}")
# 大致 125k entities / 203 relations / 1.7k timestamps / 328k facts

6.2 PyTorch 实现 TComplEx 嵌入与训练

以下是一个最小可运行的 TComplEx 实现(教学版,不追求极致效率),用于在 ICEWS14 等数据集上做链路预测,可直接作为 CronKGQA 的预训练嵌入。

import torch
import torch.nn as nn
import torch.nn.functional as F

class TComplEx(nn.Module):
    """
    TComplEx (Lacroix et al., ICLR 2020).
    嵌入维度 rank,实部+虚部各占 rank,因此参数总量为 2*rank。
    """
    def __init__(self, n_entities: int, n_relations: int,
                 n_timestamps: int, rank: int = 200):
        super().__init__()
        self.rank = rank
        # 三个 lookup table:实部 + 虚部 拼接为 2*rank 维
        self.embeddings = nn.ModuleList([
            nn.Embedding(n_entities,   2 * rank, sparse=False),  # 0: entities
            nn.Embedding(n_relations,  2 * rank, sparse=False),  # 1: relations
            nn.Embedding(n_timestamps, 2 * rank, sparse=False),  # 2: timestamps
        ])
        # Xavier 初始化,缩小到 0.1 以稳定训练
        for emb in self.embeddings:
            nn.init.xavier_uniform_(emb.weight, gain=0.1)

    def score(self, s, r, o, t):
        """对四元组 (s,r,o,t) 打分,值越高越可信。
           输入均为 LongTensor [batch]。"""
        es = self.embeddings[0](s)                # [B, 2R]
        er = self.embeddings[1](r)
        eo = self.embeddings[0](o)
        et = self.embeddings[2](t)

        # 拆出实部 / 虚部
        es_re, es_im = es[:, :self.rank], es[:, self.rank:]
        er_re, er_im = er[:, :self.rank], er[:, self.rank:]
        eo_re, eo_im = eo[:, :self.rank], eo[:, self.rank:]
        et_re, et_im = et[:, :self.rank], et[:, self.rank:]

        # 时间调制关系: rt = r ⊙ t (复数乘法)
        rt_re = er_re * et_re - er_im * et_im
        rt_im = er_re * et_im + er_im * et_re

        # ComplEx 打分: Re(<es, rt, conj(eo)>)
        score = (es_re * rt_re * eo_re
                 + es_re * rt_im * eo_im
                 + es_im * rt_re * eo_im
                 - es_im * rt_im * eo_re).sum(dim=-1)
        return score

    def forward_all_objects(self, s, r, t):
        """对固定 (s, r, t),对所有候选 o 打分(用于训练 1-vs-all CE)。"""
        es = self.embeddings[0](s)
        er = self.embeddings[1](r)
        et = self.embeddings[2](t)
        es_re, es_im = es[:, :self.rank], es[:, self.rank:]
        er_re, er_im = er[:, :self.rank], er[:, self.rank:]
        et_re, et_im = et[:, :self.rank], et[:, self.rank:]
        rt_re = er_re * et_re - er_im * et_im
        rt_im = er_re * et_im + er_im * et_re
        # 头实体侧的复合向量
        h_re = es_re * rt_re - es_im * rt_im
        h_im = es_re * rt_im + es_im * rt_re
        # 与所有候选实体做点积
        all_E = self.embeddings[0].weight  # [N, 2R]
        all_re, all_im = all_E[:, :self.rank], all_E[:, self.rank:]
        scores = h_re @ all_re.t() + h_im @ all_im.t()    # [B, N]
        return scores

# -------- 训练循环(简化版) --------
def train_one_epoch(model, loader, opt, device, reg_weight=1e-3):
    model.train()
    total = 0.0
    for s, r, o, t in loader:                                # 来自 ICEWS14 train.txt
        s, r, o, t = (x.to(device) for x in (s, r, o, t))
        scores = model.forward_all_objects(s, r, t)          # [B, N]
        loss = F.cross_entropy(scores, o)                    # 1-vs-all
        # nuclear 4-norm 正则(对当前 batch 中出现的嵌入)
        reg = (model.embeddings[0](s).pow(4).sum()
               + model.embeddings[1](r).pow(4).sum()
               + model.embeddings[2](t).pow(4).sum()) / s.size(0)
        loss = loss + reg_weight * reg
        opt.zero_grad(); loss.backward(); opt.step()
        total += loss.item()
    return total / len(loader)

关键点解读:

• 实部 / 虚部都存在同一个 nn.Embedding 里(2*rank 维),通过切片访问;
• rt = r ⊙ t 即 Hadamard 复数乘法,等价于时间对关系做"旋转 + 缩放";
• 训练目标采用 1-vs-all 交叉熵(等同于全候选 softmax),实证比 margin loss 更稳;
• 正则化用 nuclear 4-norm 的 batch 近似,Lacroix 等论文里强调该正则对收敛非常关键。

6.3 用 HuggingFace + LangChain 搭建 TKGQA pipeline

下面是一个把"子图检索 → Prompt 拼装 → LLM 推理"串起来的 minimal RAG pipeline,适合复现 KG-RAG 类 baseline。

# pip install transformers langchain sentence-transformers
import torch
from typing import List, Tuple
from transformers import AutoTokenizer, AutoModelForCausalLM
from sentence_transformers import SentenceTransformer, util

# -------- 1) TKG 索引(简化:全部塞进内存,生产级请用 FAISS) --------
class TKGIndex:
    def __init__(self, facts: List[Tuple[str, str, str, str]],
                 encoder_name="sentence-transformers/all-MiniLM-L6-v2"):
        self.facts = facts                                       # [(s, r, o, t), ...]
        self.encoder = SentenceTransformer(encoder_name)
        # 把每条事实序列化为自然语言句子,便于语义检索
        sents = [f"({s}, {r}, {o}) at {t}" for s, r, o, t in facts]
        self.emb = self.encoder.encode(sents, convert_to_tensor=True,
                                       show_progress_bar=True)

    def retrieve(self, question: str, top_k=15) -> List[str]:
        q_emb = self.encoder.encode(question, convert_to_tensor=True)
        hits  = util.semantic_search(q_emb, self.emb, top_k=top_k)[0]
        return [f"({self.facts[h['corpus_id']]})" for h in hits]

# -------- 2) LLM(可换成 LLaMA2-Chat-7B 等) --------
class LocalLLM:
    def __init__(self, model_name="meta-llama/Llama-2-7b-chat-hf"):
        self.tok = AutoTokenizer.from_pretrained(model_name)
        self.lm  = AutoModelForCausalLM.from_pretrained(
            model_name, torch_dtype=torch.float16, device_map="auto")

    def generate(self, prompt: str, max_new_tokens=128) -> str:
        ids = self.tok(prompt, return_tensors="pt").to(self.lm.device)
        out = self.lm.generate(**ids, max_new_tokens=max_new_tokens,
                               do_sample=False, temperature=0.0)
        return self.tok.decode(out[0][ids["input_ids"].shape[1]:],
                               skip_special_tokens=True).strip()

# -------- 3) Prompt 模板(可加入 CoT) --------
PROMPT_TPL = """你是一个时序知识图谱问答助手。
请仅依据下面的相关事实(每条形如 (subject, relation, object, time))回答问题。
如果事实不足,请明确说"未知"。

【相关事实】
{evidence}

【问题】
{question}

请先一步步分析时间约束,再给出最终答案。
最终答案:"""

# -------- 4) Pipeline 主流程 --------
def tkgqa_pipeline(question, kg_index, llm, top_k=15):
    facts = kg_index.retrieve(question, top_k=top_k)
    evidence = "\n".join(facts)
    prompt = PROMPT_TPL.format(evidence=evidence, question=question)
    answer = llm.generate(prompt)
    return answer, facts

# -------- 5) 示例调用 --------
if __name__ == "__main__":
    demo_facts = [
        ("Barack_Obama", "position_held", "President_of_USA", "2009"),
        ("Barack_Obama", "position_held", "President_of_USA", "2017"),
        ("Donald_Trump", "position_held", "President_of_USA", "2017"),
        ("Joe_Biden",    "position_held", "President_of_USA", "2021"),
    ]
    kg_index = TKGIndex(demo_facts)
    llm = LocalLLM("meta-llama/Llama-2-7b-chat-hf")
    ans, ev = tkgqa_pipeline("Who was US president immediately after Obama?",
                             kg_index, llm)
    print("Evidence:", ev)
    print("Answer:", ans)

7. 关键挑战与未来研究方向

7.1 时间推理能力的瓶颈

即使最强的 GenTKGQA 在 Complex-CronQuestions 上仍有约 4% 的差距;在 MultiTQ 的 Multiple 类问题上,TimeR⁴ 也只有 0.335,说明多约束、隐式、跨粒度推理仍是硬骨头。前沿尝试包括:神经符号方法(Prog-TQA)、链式推理强化学习、Allen 时序逻辑显式嵌入。

7.2 长尾时间事件与数据漂移

LLM 预训练截止日期之后的事实(例如 2025 年的政治变动)无法被模型记住,这要求 RAG / 知识更新机制。CLTSQA(Yang et al., 2024)等工作尝试时序记忆回放(temporal memory replay)和对比学习,值得跟进。

7.3 多粒度时间表达

MultiTQ 显示模型在日粒度问题上的表现远不如年粒度,反映 TComplEx 时间嵌入数量随粒度增长而稀疏化。可能方向:(a) 用连续时间表示(Fourier features、time2vec);(b) 层次化时间嵌入,共享父粒度参数。

7.4 跨语言与多模态 TKGQA

当前数据集几乎都为英文;中文 TKGQA(基于 CN-DBpedia、OwnThink)严重缺失。多模态方面,事件图常伴随图片/视频证据(GDELT 含 multimedia),如何在 TKGQA 中融合视觉/文本/结构尚属空白。

7.5 可解释性与可信度

RAG 路线本身就提供事实链作为解释,但需要进一步评测忠实度(faithfulness)——Jia et al. (WWW 2024) 的 "Faithful Temporal QA over Heterogeneous Sources" 是早期尝试。LLM 给出的 reasoning trace 是否真的对应所用事实,亟需自动评测方法。

7.6 与大模型融合的前沿方向

• Tool-augmented LLM: 把 TKG 当作"工具",LLM 通过函数调用(如 query_tkg(s=Obama, r=position_held, t=2010))与之交互。
• Agentic Reasoning: ReAct + 强化学习反馈,让 LLM 学会"何时停止检索";最新如 Reinforcement Learning Enhanced Multi-hop Reasoning(arXiv:2601.01195)。
• 持续学习与知识编辑: 当 TKG 增添新四元组,如何避免重新训练 LLM——通过 LoRA + KG cache 的轻量更新。
• 评测基准的更新: ComplexTempQA、TimelineKGQA、TIQ 等新基准弥补 CronQ 饱和问题,建议研究生选题时优先在这些更具挑战性的数据集上验证。

8. 学习资源与参考文献

8.1 综述论文

• Su, M., et al. Temporal Knowledge Graph Question Answering: A Survey. arXiv:2406.14191, 2024.(最权威综述,含分类与 leaderboard)
• Cai, B., et al. Temporal Knowledge Graph Completion: A Survey. 2023.
• Lan, Y., et al. Complex Knowledge Base Question Answering: A Survey. IEEE TKDE 2022.

8.2 核心论文清单(30+ 篇)

8.3 开源代码仓库

• apoorvumang/CronKGQA:CronKGQA 官方实现 + CronQuestions 数据。
• cmavro/TempoQR:TempoQR 实现,基于 CronKGQA 改造。
• czy1999/SubGTR:SubGTR + Complex-CronQuestions 子集。
• czy1999/MultiTQ:MultiTQ 数据集 + MultiQA baseline。
• czy1999/ARI-QA:ARI 框架。
• zhenjia2017/EXAQT:EXAQT + TimeQuestions。
• facebookresearch/tkbc:TComplEx 官方实现(也是后续 TKGQA 嵌入起点)。
• qianxinying/TimeR4:TimeR⁴ 官方实现。
• PascalSun/TimelineKGQA:TimelineKGQA 问答对生成器。

8.4 推荐学习路径(给入门研究生的 4 周计划)

1. 第 1 周:精读 CronKGQA + TComplEx 论文,跑通 CronKGQA 仓库的 train / eval。
2. 第 2 周:精读 TempoQR、SubGTR、EXAQT,理解 hard vs soft supervision、子图检索路线。
3. 第 3 周:跑通 GenTKGQA 或 Prog-TQA,在 MultiTQ 上对比 LLM-based 方法。
4. 第 4 周:选定方向(可解释性 / 多粒度 / 隐式时间 / 持续学习)阅读最新 2025 论文,写 proposal。

© 2026 TKGQA 入门教程 · 本文统计与排行均来自公开发表论文,数据如有更新以原论文为准。