Text-to-Temporal Graph Translation

• Text-to-temporal graph translation is a process that converts unstructured text into structured graphs with nodes representing events and time expressions, and edges encoding temporal relations.
• Various approaches employ joint extraction models, time-aware embeddings, and graph transformers to detect events and classify temporal relations with improved precision.
• These techniques enable advanced downstream tasks such as temporal reasoning and question answering by facilitating the structured analysis of complex event sequences.

Text-to-temporal graph translation is the process of converting unstructured or semi-structured natural language text into a structured temporal graph representation, where nodes correspond to events, time expressions, entities, or sentences, and edges encode temporal relations such as BEFORE, AFTER, SIMULTANEOUS, INCLUDES, and more. This structured form facilitates downstream temporal reasoning, question answering, and complex event understanding. Multiple lines of research pursue this task, employing joint extraction models, time-aware embeddings, structure-aware pretraining objectives, and Transformers fused with explicit temporal graphs. The approaches differ with respect to node and edge granularity, event detection mechanics, and fusion with neural architectures.

1. Formal Problem Definitions

Text-to-temporal graph translation maps textual input into a directed (multi-)graph $G=(V, E)$ with temporally labeled edges:

• Temporal event relation extraction seeks $G$ where $V$ is the set of event trigger nodes, $E\subset V\times V\times L$ are labeled edges with $L$ given by a set of temporal relations such as {Before, After, Simultaneous, Vague, ...}. The objective is to predict, for each ordered node pair $(e_s, e_t)$, a relation label $ℓ$ (Zhang et al., 2021).
• Sentence-level time-scoped graphs (as in RemeMo) use nodes for sentences $S_i$ annotated with normalized time spans $T_i = [t_i^\mathrm{start}, t_i^\mathrm{end})$, and edges labeled by the relative order (“Earlier”, “Later”, “Contemporary”) via interval comparison (Yang et al., 2023).
• Fine-grained temporal graphs (as in TG-LLM) are defined as $G=(V,E)$ where $G$0 is a set of entities (people, places, etc.), $G$1 is a set of edges $G$2 encoding the subject/object, relation type, and explicit start/end times (Xiong et al., 2024).
• Time-sensitive QA graphs take event and time nodes extracted from documents and questions, constructing edges via both rule-based systems and data-driven transitive propagation (Su et al., 2023).

In general, the mapping from text to temporal graph requires robust event/time detection, normalization, and relation classification with varying types of nodes and granularity.

2. Event and Time Node Extraction

Node identification is the first essential task and differs across frameworks:

• Event trigger detection: Neural classifiers (e.g., BERT-based) label tokens as event triggers. Consecutive triggers form an event node, whose representation may be derived from contextual token embeddings or fine-tuned parameter matrices (Zhang et al., 2021).
• Time expression recognition and normalization: Sequence-taggers (NER-style) label B-TIME/I-TIME/O tags per token, which are then normalized to formal representations (e.g., ISO dates, TimeML) (Yang et al., 2023, Su et al., 2023).
• Document-level time and entity extraction: Tools like SUTime and CAEVO extract time expressions and event predicate mentions, respectively; question time spans are often extracted via regex-based systems or gold annotations (Su et al., 2023).
• Sentence scoping: Only sentences with a valid normalized time-span are kept as graph nodes for relative-time modeling; if multiple spans are present, these are merged to create a minimal-to-maximal interval (Yang et al., 2023).
• Entity-based graphs: In synthetic datasets, nodes correspond to anonymized entities linked by events, with temporal information given by start/end timestamps (Xiong et al., 2024).

3. Temporal Relation Edge Construction

Edge definition strategy is highly context-dependent:

• Dependency and syntax-guided extraction: Dependency trees are employed to define shortest paths and relation cue sets between pairs of events; attention mechanisms focus model capacity on syntactically-relevant paths, enhancing disambiguation for distant event pairs (Zhang et al., 2021).
• Explicit interval comparison: Temporal relations between intervals $G$3 and $G$4 are based on their endpoints. For example, if $G$5, relation is “Earlier”; if intervals overlap, relation is “Contemporary” (Yang et al., 2023, Su et al., 2023).
• Transitive propagation and Allen’s interval logic: For event-time or question-time to document-event edges, shortest paths and transitive compositions using Allen’s interval algebra propagate edge labels. Explicit fusion algorithms maintain graph consistency (Su et al., 2023).
• Textual signal integration: Edge weights may be computed as a convex combination of text-only similarity, time-aware text similarity, and time-only correlation, learned via a mixture model and normalized subgraph-matching objectives (Hosseini et al., 2019).
• Neural generation: In LLM-centric models (e.g., TG-LLM), edge event tuples are directly generated as serialized text and parsed post hoc, with events sorted by their temporal start (Xiong et al., 2024).

4. Model Architectures and Algorithms

Several fundamental algorithmic strategies underpin text-to-temporal-graph translation:

• Syntax-guided Graph Transformer (SGT): Integrates dependency-tree structure into a Transformer backbone, with both graph-based self-attention over syntactic neighbors and pairwise syntax-guided attention over event pairs. Update rules fuse self-attended and syntax-guided representations, with supervised cross-entropy losses for both node (event) detection and temporal relation classification (Zhang et al., 2021).
• Relative-Time Modeling and Pretraining (RemeMo): Constructs a fully-connected temporal sentence-level graph, then jointly pretrains a T5 encoder on denoising (LM) and pairwise temporal relation classification (TRC). Edge labels are assigned via interval comparison; loss is the sum of T5 denoising and TRC losses (Yang et al., 2023).
• Temporal Embedding and Graph Mining (TEAGS/TEALS): Employs multi-facet (hour/day/week/month) temporal-slice word embeddings, merges them with a temporal generative model via EM, then uses a max-heap graph-cutting algorithm to discover coherent temporal subgraphs. The loss combines GloVe-style objectives with time-aware coefficients (Hosseini et al., 2019).
• LLM-Based Sequence Transduction (TG-LLM): Treats graph translation as seq2seq generation using a large LLM (e.g., Llama-2) fine-tuned with LoRA adapters, supervised with cross-entropy on tokenized target TG serializations. Inference is performed by greedy/beam decoding and post-processing (Xiong et al., 2024).
• Graph Injection into Transformers: Extracted temporal graphs are fused into Transformer encoders via (a) explicit edge representation—injecting XML-style markers into token sequences—or (b) augmenting token embeddings using relational graph convolutional networks over the temporal graph adjacency tensor (Su et al., 2023).
• Worked Example: The SGT model on the sentence “John worked before retiring” yields nodes for "worked" and "retiring"; dependency-parse triples and syntax-guided attention isolate the "prep: before" and "pcomp" arcs, resulting in worked→retiring labeled as "After" (Zhang et al., 2021).

5. Training Objectives and Evaluation Metrics

Supervised learning remains the standard, with loss functions reflecting the joint structure of the temporal graph:

• Cross-entropy event detection and relation classification: Token-level binary classification for event triggers, pairwise softmax for temporal relation labels. Class imbalance is compensated by weighting factors (Zhang et al., 2021).
• Joint multi-task pretraining: Relative-time classification losses are combined with LM denoising objectives; all temporal relation predictions are included in the TRC loss (Yang et al., 2023).
• Subgraph-mining F1: Precision, recall, and F1 scores are measured on subgraph extraction, with TP/FP/FN/TN definitions tied to correlated infection categories within time intervals (Hosseini et al., 2019).
• Exact match, token-level F1, and accuracy: Evaluated over serialized TG outputs and question answering performance using lowest perplexity from LLM decoding (Xiong et al., 2024).

6. Empirical Performance and Benchmarks

Empirical evaluation highlights the importance of syntactic structure, time normalization, and rich feature fusion:

• SGT on MATRES/TB-Dense: SGT achieves 62.3 F1 (MATRES joint extraction), outperforming prior state-of-the-art (HNP19, 59.6) (Zhang et al., 2021).
• RemeMo on temporal QA: RemeMo outperforms baseline T5 on multiple datasets, especially excelling at long-range dependencies (Yang et al., 2023).
• TEALS on alarm propagation graphs: TEALS improves subgraph-mining F1 to 0.65 over rivals (up to +0.15 F1 vs. prior state-of-the-art). Time-aware embeddings capture semantic drift and improve robustness to sparsity (Hosseini et al., 2019).
• TG-LLM on TGQA: Llama-2 + LoRA after SFT-TG achieves EM=0.797, F1=0.850, Acc=0.819, outperforming GPT-3.5 ICL and nearly matching GPT-4 (Xiong et al., 2024).
• Fusing temporal graphs for QA: Explicit edge representation (ERR) fusion into LongT5-base gave the best accuracy on TimeQA and SituatedQA (Su et al., 2023). Graph-convolutional network fusion is less effective without extensive fine-tuning.

7. Limitations and Open Challenges

Several challenges and limitations remain:

• Event and time span extraction: Methods reliant on explicit normalized time expressions cannot capture implicit or event-based temporal relations (“last Tuesday,” vague mentions) (Yang et al., 2023).
• Edge density and scalability: O($G$6) edge matrices or all-pair scoring can be computationally prohibitive for long documents or high-sentence contexts; edge subsampling or chunking is commonly used (Yang et al., 2023).
• Granularity: Merging multiple time tags into coarse intervals sacrifices fine-grained distinctions when sentences mention several distinct times (Yang et al., 2023).
• Graph consistency: Some methods guarantee transitivity or enforce interval algebra; others rely on post-hoc correction or explicit propagation (Yang et al., 2023, Su et al., 2023).
• Domain transfer: Synthetic graph-to-text datasets facilitate large-scale supervision but may not generalize to real-world event/event/QA complexities without domain adaptation (Xiong et al., 2024).
• Complexity of subgraph detection: Exact maximum-weight matching is NP-hard; greedy max-heap cuts offer 1/2-approximation guarantees but may miss optimal subgraphs (Hosseini et al., 2019).
• Temporal facet discovery: Fixed temporal dimensions (hour, day, week, month) may be suboptimal; automated facet discovery remains open (Hosseini et al., 2019).

---

Text-to-temporal graph translation, across its various formalizations, is now supported by a suite of neural, statistical, and hybrid methods that combine explicit linguistic structure with neural induction, yielding significant advances in temporal relation understanding, question answering, and subgraph discovery. The field continues to evolve as work integrates finer normalization, more robust event and time extraction, scalable reasoning modules, and flexible, domain-adaptive architectures.