HTML Scala Ruby TeX Perl Python Other
Latest commit 51fa91f
|Failed to load latest commit information.|
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.