Parsing Time: Learning to Interpret Time Expressions
----------
Abstract:
----------
We present a probabilistic approach for learning to interpret temporal
phrases given only a corpus of utterances and the times they reference.
While most approaches to the task have used regular expressions and similar
linear pattern interpretation rules, the possibility of phrasal embedding
and modification in time expressions motivates our use of a compositional
grammar of time expressions. This grammar is used to construct a latent
parse which evaluates to the time the phrase would represent, as a logical
parse might evaluate to a concrete entity. In this way, we can employ a
loosely supervised EM-style bootstrapping approach to learn these latent
parses while capturing both syntactic uncertainty and pragmatic ambiguity
in a probabilistic framework. We achieve an accuracy of 72% on an adapted
TempEval-2 task -- comparable to state of the art systems.
----------
Compilation
----------
Scala 2.9.1
JavaNLP April 9 2012
Most experiments can be run with something in the rc file
interpret: run the interpretation model (last valid run)
interpretAux: run the interpretation model (good parameters)
sutimeInterpret: run SUTime
heideltimeInterpret: run HeidelTime
gutimeInterpret: run GUTime
detect: run the detection model (last valid run)
Models
dist/time.jar: the program
dist/interpretModel.ser.gz: serialized temporal interpretation model
dist/detectModel.ser.gz: serialized temporal detection model (includes
interpretation model)
dist/log.gz: the log from the run producing interpretModel.ser.gz
dist/options: the command line options from the run
----------
TOUR
----------
Some key classes are explained below. This is not an exhaustive list, but
hopefully can help give a sense for the code.
Data.scala: Utilities for working with tempeval data, or the CoreMaps created
from them
class TimeDataset: holds the CoreMaps corresponding to the raw data
object DataLib: utilities for working with the data
Detect.scala: Code for the detection model
class CRFFeatures: the definition of the features used
class CRFDetector: the class which performs and aggregates the detections
class DetectionDatum: encapsulates the input information for detecting a
time during training
class CoreMapDetectionStore: the dataset used for detection; handles
iterating over the data
class DetectionTask: trains the CRF detection module
Entry.scala: General purpose code and main methods
class Indexing: handles moving between strings and ints for POS and words
object G: general utility fields
object U: general utility functions
class TimeSent: Embodies a sentence sent to the CKY parser
trait DataStore: interface for a block of data (train/dev/test)
*object Interpret: MAIN for running interpretation or detection for
either our system or another system (via a CoreNLP Annotator)
*object Entry: MAIN for training the models; this is the usual entry
point for the program, when not evaluating
Gigaword.scala: Some old code to try to get more training instances from
automatically parsed data
Interpret.scala: Most of the code for the interpretation model lives here
class Grammar: defines the grammar used in CKY parsing
object Grammar: creates the actual temporal grammar
*class TreeTime: MODEL this is our model, which can be serialized and loaded.
It is also a CoreNLP annotator, and does both detection and interpretation.
class InterpretationTask: The code for training the interpretation model
O.java: All the options for training the model(s). Some of these may be dead
Tempeval2.scala: Code for processing the TempEval data into CoreMaps
Temporal.scala: The temporal representation
trait Temporal: all temporal representations subclass this
trait Range: all ranges subclass this (see paper)
trait Duration: all durations subclass this (see paper)
trait Sequence: all sequences subclass this (see paper). Note that it is
both a Range and a Duration as well
class Time: a point in time
class GroundedRange: the conventional begin-to-end range (e.g., 1998)
class UngroundedRange: a 'floating' range (e.g., today)
class GroundedDuration: the conventional x-milliseconds type of duration
class FuzzyDuration: an approximate duration
class RepeatedRange: the standard range-every-n-milliseconds type of sequence
class CompositeRange: a complex sequence that we can't evaluate analytically
class NoTime: returned when an invalid operation is performed and no such
time actually exists (e.g., Feb 30)
class UnkTime: a time that we can't represent
object Range: utility functions for handling ranges, notably intersecting
*object Time: MAIN for running an interactive shell for evaluating temporal
expressions. This is actually kind of a nifty domain specific language.
object Lex: the definitions of times used in the grammar
----------
Notes
----------
- The clases in etc/ are licensed under various licenses -- they're included
here to make compilation easier, but care should be taken when using this
code in any commerical setting to respect their respective licenses.