Abstract
Extracting temporal information from natural language text is a fundamental challenge in Natural Language Processing (NLP), essential for tasks such as question-answering, document summarization, and event ordering. This paper proposes a two-stage framework, DANTE (Detection and Normalisation of Temporal Expressions), which introduces an intermediate semantic representation to decouple the linguistic recognition of temporal expressions from their pragmatic interpretation. By separating these concerns, the framework provides a modular and robust approach to handling the inherent ambiguity and underspecification of time-related language.
Introduction
Temporal expressions are a cornerstone of human communication, yet they are notoriously difficult for computational systems to process. While some expressions are explicit (e.g., "January 1st, 2000"), many are underspecified (e.g., "3pm on the first Tuesday in November") or relative (e.g., "last year," "tomorrow").
The primary difficulty in existing NLP systems is the conflation of two distinct cognitive and computational steps:
- Recognition: The identification of tokens that constitute a temporal expression and the extraction of their context-free meaning (e.g., recognizing that "Tuesday" refers to a specific day of the week).
- Interpretation: The application of document metadata, such as the Reference Time (RefTime), and surrounding linguistic context (like verb tense) to calculate a specific, standardized date-time value.
Without a formal intermediate representation, systems often become "black boxes" that are difficult to debug, compare, or adapt to new domains. This paper argues for a standardized "middle ground" that allows for more granular and modular development of temporal extraction pipelines.
The DANTE Framework
The authors propose the DANTE framework, which mediates the transition from raw text to normalized values through a structured intermediate representation. This process is divided into a clear pipeline:
1. Recognition and the Intermediate Representation
The first stage uses the Java Annotation Patterns Engine (JAPE) within the GATE framework to identify temporal expressions. Instead of attempting to calculate a final ISO-8601 date immediately, the system generates an Intermediate Representation (IR).
Initially, the authors conceptualized this IR using Attribute-Value Matrices (AVMs). For instance, the expression "November 11th" would be stored in a matrix where the day and month attributes are populated, but the year attribute remains NULL. To enhance practical utility and compatibility with existing standards, they adapted this into a string-based notation based on the TIMEX2 standard:
- Placeholders: The character
xdenotes values that must be resolved during the interpretation phase (e.g.,xxxx-11-11for "November 11th"). - Relative Operators: Symbols like
+or-represent offsets from a reference point (e.g.,+0000-00-01for "tomorrow"). - Functional Logic: Complex expressions like "next Thursday" are encoded using symbols like
>D4, indicating the fourth day of the week following the reference date.
2. Interpretation
The second stage is an interpretation module that consumes the IR strings. This module utilizes document timestamps, arithmetic routines, and linguistic cues to "fill in the gaps." This process is designed to be monotonically augmenting, meaning it adds information to the IR without overwriting the initial linguistic findings, ensuring the logic remains predictable and traceable.
Evaluation and Coverage
To validate the robustness of their proposed representation, the authors evaluated its coverage against the TIMEX2 specification. They curated a corpus of approximately 250 examples derived directly from the TIDES/TIMEX2 annotation guidelines. These examples represent the full spectrum of temporal complexity found in real-world data, including durations, points in time, and recurring sets. The framework successfully encoded these diverse expressions, demonstrating that the intermediate representation is sufficiently expressive for broad-coverage NLP applications.
Key Insights
- Separation of Concerns: Decoupling recognition from interpretation allows researchers to optimize the linguistic components of a system independently of the mathematical logic required for date calculation.
- Granularity Management: The representation explicitly handles varying levels of precision. If a text refers to "the '60s," the system recognizes the granularity as a decade and avoids forcing a specific day or month unless required by the output standard.
- Modular Arithmetic: By storing the intent of an expression (e.g., "the day after") rather than a hardcoded date, the system remains flexible to changes in the Reference Time.
Conclusion and Future Work
This paper presents a significant step toward a standardized architecture for temporal expression processing. By moving away from direct normalization, the DANTE framework offers a more transparent and maintainable approach. While the current work focuses primarily on points in time, the authors suggest that the representation is naturally extensible to durations and sets. Future work aims to address the deeper pragmatic challenges of temporal ambiguity, such as determining the specific intent behind subjective expressions like "next week," which can vary significantly between speakers and contexts.
Summary updated