Timelines from Text Finding Event Order and Relations in Narratives - - PowerPoint PPT Presentation
Timelines from Text Finding Event Order and Relations in Narratives David Woods dwoods@tcd.ie Introduction Strings of Events Combinations of Worlds Intervals, Points, and Borders Outline Temporal Information in Text What Does It Look Like?
David Woods dwoods@tcd.ie
Introduction Strings of Events Combinations of Worlds Intervals, Points, and Borders Temporal Information in Text What Does It Look Like? Applications Questions?
What exactly are we trying to do?
What exactly are we trying to do? Build a system to automatically extract a (possibly non-deterministic) linear order over the events and times mentioned in a text.
What exactly are we trying to do? Why? Build a system to automatically extract a (possibly non-deterministic) linear order over the events and times mentioned in a text.
What exactly are we trying to do? Why? Build a system to automatically extract a (possibly non-deterministic) linear order over the events and times mentioned in a text. Tooling for computer-aided annotation, improving QA systems, …
What exactly are we trying to do? Why? What use are strings? Build a system to automatically extract a (possibly non-deterministic) linear order over the events and times mentioned in a text. Tooling for computer-aided annotation, improving QA systems, …
What exactly are we trying to do? Why? What use are strings? Build a system to automatically extract a (possibly non-deterministic) linear order over the events and times mentioned in a text. Tooling for computer-aided annotation, improving QA systems, … Strings are basic computational entities, and are amenable to finite-state methods. Plus they look a bit like timelines already!
e1 e2 e3 e4 e5 e6 e7 e8 e10 e9 e11 ...
Some related work:
meaning
a text We’ll cover these shortly!
What exactly do we mean by a “string”?
What exactly do we mean by a “string”? A sequence of symbols...
What exactly do we mean by a “string”? A sequence of symbols... Each symbol represents a set which contains some information we’re interested in. By allowing finite sets to be encoded as symbols, we can have strings of sets.
What exactly do we mean by a “string”? A sequence of symbols... Each symbol represents a set which contains some information we’re interested in. By allowing finite sets to be encoded as symbols, we can have strings of sets. {1, 2, 3}, {5, 8}, { }, {3} ...
What exactly do we mean by a “string”? A sequence of symbols... Each symbol represents a set which contains some information we’re interested in. By allowing finite sets to be encoded as symbols, we can have strings of sets. {1, 2, 3}, {5, 8}, { }, {3} {x, y}, {y}, {y, z} ...
What exactly do we mean by a “string”? A sequence of symbols... Each symbol represents a set which contains some information we’re interested in. By allowing finite sets to be encoded as symbols, we can have strings of sets. {1, 2, 3}, {5, 8}, { }, {3} {x, y}, {y}, {y, z} {cats}, {dogs}, {rabbits} ...
What exactly do we mean by a “string”? A sequence of symbols... Each symbol represents a set which contains some information we’re interested in. By allowing finite sets to be encoded as symbols, we can have strings of sets. {1, 2, 3}, {5, 8}, { }, {3} {x, y}, {y}, {y, z} {cats}, {dogs}, {rabbits} {event1, event2}, {event3} ...
Each set will contain temporal data, called fluents, which represent times and events.
Each set will contain temporal data, called fluents, which represent times and events. For example, the fluent js might correspond to an event such as “John sleeps”, and t1 might be a timepoint like “1pm”.
Each set will contain temporal data, called fluents, which represent times and events. For example, the fluent js might correspond to an event such as “John sleeps”, and t1 might be a timepoint like “1pm”. By including these fluents in the same set, we indicate they occurred concurrently: ..., {js, t1}, ...
Each set will contain temporal data, called fluents, which represent times and events. For example, the fluent js might correspond to an event such as “John sleeps”, and t1 might be a timepoint like “1pm”. By including these fluents in the same set, we indicate they occurred concurrently: ..., {js, t1}, ... The left-to-right order of the sets in the string represents the chronological ordering of the temporal data.
Each set will contain temporal data, called fluents, which represent times and events. For example, the fluent js might correspond to an event such as “John sleeps”, and t1 might be a timepoint like “1pm”. By including these fluents in the same set, we indicate they occurred concurrently: ..., {js, t1}, ... The left-to-right order of the sets in the string represents the chronological ordering of the temporal data. Each set represents a compressible moment of time, with no assumptions as to its real-world duration.
Each set will contain temporal data, called fluents, which represent times and events. For example, the fluent js might correspond to an event such as “John sleeps”, and t1 might be a timepoint like “1pm”. By including these fluents in the same set, we indicate they occurred concurrently: ..., {js, t1}, ... The left-to-right order of the sets in the string represents the chronological ordering of the temporal data. Each set represents a compressible moment of time, with no assumptions as to its real-world duration. Therefore, they correspond to intervals of time (we’ll come back to this idea later).
In case you’re interested...
In case you’re interested...
consisting of n moments of time, i ∈ {1, ..., n}.
In case you’re interested...
consisting of n moments of time, i ∈ {1, ..., n}.
In case you’re interested...
consisting of n moments of time, i ∈ {1, ..., n}.
In case you’re interested...
consisting of n moments of time, i ∈ {1, ..., n}.
– Aristotle, Physics IV
To save on writing out braces {...} for every set, and to reinforce the notion of a timeline, we use boxes ... to contain the sets in our strings.
{x, y}, {y}, {y, z}
To save on writing out braces {...} for every set, and to reinforce the notion of a timeline, we use boxes ... to contain the sets in our strings. The boxes are glued together in sequence to form the same string.
{x, y}, {y}, {y, z} x, y y y, z
To save on writing out braces {...} for every set, and to reinforce the notion of a timeline, we use boxes ... to contain the sets in our strings. The boxes are glued together in sequence to form the same string. Note that an empty set/box is not the same as an empty string! Other events may be occurring during this time, but they are not named in our alphabet.
{x, y}, {y}, {y, z} x, y y y, z {x, y}, { }, {y, z} x, y y, z
Since we don’t assign a fixed duration to any box, the strings may stutter without its interpretation being affected.
Since we don’t assign a fixed duration to any box, the strings may stutter without its interpretation being affected. a a, b a, b b
a a, b b
Since we don’t assign a fixed duration to any box, the strings may stutter without its interpretation being affected. A string component can stutter any number of times in this way. a a, b a, b b
a a, b b
Since we don’t assign a fixed duration to any box, the strings may stutter without its interpretation being affected. A string component can stutter any number of times in this way. Being able to intentionally introduce and remove stutter in a string will be convenient in the next section. a a, b a, b b
a a, b b
Since we don’t assign a fixed duration to any box, the strings may stutter without its interpretation being affected. A string component can stutter any number of times in this way. Being able to intentionally introduce and remove stutter in a string will be convenient in the next section. We will consider a string with no stutter to be the simplest representation of that sequence of events. a a, b a, b b
a a, b b
One assumption to take note of here is that each symbol in our fluent alphabet names an event instance, rather than an event.
One assumption to take note of here is that each symbol in our fluent alphabet names an event instance, rather than an event. This means that if an event were to stop, and then start again later, the distinct parts must be named uniquely.
One assumption to take note of here is that each symbol in our fluent alphabet names an event instance, rather than an event. This means that if an event were to stop, and then start again later, the distinct parts must be named uniquely. This prevents confusion and helps identify inconsistencies.
One assumption to take note of here is that each symbol in our fluent alphabet names an event instance, rather than an event. This means that if an event were to stop, and then start again later, the distinct parts must be named uniquely. This prevents confusion and helps identify inconsistencies. For example, “It rained from 10 till noon, then again from 3 till 9.”
One assumption to take note of here is that each symbol in our fluent alphabet names an event instance, rather than an event. This means that if an event were to stop, and then start again later, the distinct parts must be named uniquely. This prevents confusion and helps identify inconsistencies. For example, “It rained from 10 till noon, then again from 3 till 9.” Rather than looking like rain rain
One assumption to take note of here is that each symbol in our fluent alphabet names an event instance, rather than an event. This means that if an event were to stop, and then start again later, the distinct parts must be named uniquely. This prevents confusion and helps identify inconsistencies. For example, “It rained from 10 till noon, then again from 3 till 9.” Rather than looking like rain rain A well-formed string will be more like rain1 rain2
A well-formed string will look like rain1 rain2 A realistic, Irish string will look like... rain rain rain
In essence, each string is a small representation
interested in.
In essence, each string is a small representation
interested in. A world where a happened, then b, then c.
a b c
In essence, each string is a small representation
interested in. Different strings may represent different worlds, describing alternate sequences of events which took place. A world where a happened, then b, then c.
a b c
c d a
In essence, each string is a small representation
interested in. Different strings may represent different worlds, describing alternate sequences of events which took place. A world where a happened, then b, then c.
a b c
A world where c happened before a, and d happened between them instead of b.
c d a
In essence, each string is a small representation
interested in. Different strings may represent different worlds, describing alternate sequences of events which took place. Separate strings might also represent different projections of the same world. A world where a happened, then b, then c.
a b c
A world where c happened before a, and d happened between them instead of b.
Some terminology:
Some terminology:
that string
Some terminology:
that string
vocabulary of a string to just the fluents appearing in A
Some terminology:
that string
vocabulary of a string to just the fluents appearing in A
We say a string s projects to another s' iff:
bc(ρvoc(s')(s)) = s'
Some terminology:
that string
vocabulary of a string to just the fluents appearing in A
We say a string s projects to another s' iff:
bc(ρvoc(s')(s)) = s'
Some terminology:
that string
vocabulary of a string to just the fluents appearing in A
We say a string s projects to another s' iff:
bc(ρvoc(s')(s)) = s'
i.e. Reducing s to the vocabulary of s' and then removing any stutter produces s'.
Some terminology:
that string
vocabulary of a string to just the fluents appearing in A
We say a string s projects to another s' iff:
bc(ρvoc(s')(s)) = s'
i.e. Reducing s to the vocabulary of s' and then removing any stutter produces s'. For example: s = a b, c c, d d s' = a d
Some terminology:
that string
vocabulary of a string to just the fluents appearing in A
We say a string s projects to another s' iff:
bc(ρvoc(s')(s)) = s'
i.e. Reducing s to the vocabulary of s' and then removing any stutter produces s'. For example: s = a b, c c, d d s' = a d voc(s') = {a, d}
Some terminology:
that string
vocabulary of a string to just the fluents appearing in A
We say a string s projects to another s' iff:
bc(ρvoc(s')(s)) = s'
i.e. Reducing s to the vocabulary of s' and then removing any stutter produces s'. For example: s = a b, c c, d d s' = a d voc(s') = {a, d} ρvoc(s')(s) = a d d
Some terminology:
that string
vocabulary of a string to just the fluents appearing in A
We say a string s projects to another s' iff:
bc(ρvoc(s')(s)) = s'
i.e. Reducing s to the vocabulary of s' and then removing any stutter produces s'. For example: s = a b, c c, d d s' = a d voc(s') = {a, d} ρvoc(s')(s) = a d d bc(ρvoc(s')(s)) = a d = s'
Some terminology:
that string
vocabulary of a string to just the fluents appearing in A
We say a string s projects to another s' iff:
bc(ρvoc(s')(s)) = s'
i.e. Reducing s to the vocabulary of s' and then removing any stutter produces s'. For example: s = a b, c c, d d s' = a d voc(s') = {a, d} ρvoc(s')(s) = a d d bc(ρvoc(s')(s)) = a d = s' ∴ s projects to s'
Strings become more useful when we can combine them together - fusing multiple views
Strings become more useful when we can combine them together - fusing multiple views
For example, if we have two strings a b and b c , then it would be convenient to collapse these into a single string: a b c .
Strings become more useful when we can combine them together - fusing multiple views
For example, if we have two strings a b and b c , then it would be convenient to collapse these into a single string: a b c . Not only is this more compact, it allows us to determine that a occurred before c - not obvious from either original string alone.
Strings become more useful when we can combine them together - fusing multiple views
For example, if we have two strings a b and b c , then it would be convenient to collapse these into a single string: a b c . Not only is this more compact, it allows us to determine that a occurred before c - not obvious from either original string alone. We can do this using superposition.
Strings become more useful when we can combine them together - fusing multiple views
For example, if we have two strings a b and b c , then it would be convenient to collapse these into a single string: a b c . Not only is this more compact, it allows us to determine that a occurred before c - not obvious from either original string alone. We can do this using superposition. In its most basic form, this is just the component-wise union of two strings: x y & p q = x, p y, q
Strings become more useful when we can combine them together - fusing multiple views
For example, if we have two strings a b and b c , then it would be convenient to collapse these into a single string: a b c . Not only is this more compact, it allows us to determine that a occurred before c - not obvious from either original string alone. We can do this using superposition. In its most basic form, this is just the component-wise union of two strings: x y & p q = x, p y, q Following a more complex algorithm allows superposition to asynchronously combine strings of differing lengths which are projections
1. Introduce stutter into one or both of the strings to be superposed.
1. Introduce stutter into one or both of the strings to be superposed. 2. Select strings of equal length, and perform basic superposition.
1. Introduce stutter into one or both of the strings to be superposed. 2. Select strings of equal length, and perform basic superposition. 3. Reject results which will not be well-formed (i.e. break our assumption of non-resumptive events) - we can also impose other external constraints here.
1. Introduce stutter into one or both of the strings to be superposed. 2. Select strings of equal length, and perform basic superposition. 3. Reject results which will not be well-formed (i.e. break our assumption of non-resumptive events) - we can also impose other external constraints here. 4. Collect set of remaining results.
1. Introduce stutter into one or both of the strings to be superposed. 2. Select strings of equal length, and perform basic superposition. 3. Reject results which will not be well-formed (i.e. break our assumption of non-resumptive events) - we can also impose other external constraints here. 4. Collect set of remaining results. Full details of the algorithm can be found here: https://www.scss.tcd.ie/~dwoods/isa14
Superposing in this asynchronous way can result in a set of strings (called a language) as
Superposing in this asynchronous way can result in a set of strings (called a language) as
This occurs when there is some unresolved ambiguity.
Superposing in this asynchronous way can result in a set of strings (called a language) as
This occurs when there is some unresolved ambiguity. e.g. a b & a c = ?
Superposing in this asynchronous way can result in a set of strings (called a language) as
This occurs when there is some unresolved ambiguity. e.g. a b & a c = ? We don’t know the relation between b and c in this scenario. Superposition will generate a string for every possibility.
Superposing in this asynchronous way can result in a set of strings (called a language) as
This occurs when there is some unresolved ambiguity. e.g. a b & a c = ? We don’t know the relation between b and c in this scenario. Superposition will generate a string for every possibility. The strings in a language are alternate timelines
don’t have more information.
Superposing in this asynchronous way can result in a set of strings (called a language) as
This occurs when there is some unresolved ambiguity. e.g. a b & a c = ? We don’t know the relation between b and c in this scenario. Superposition will generate a string for every possibility. The strings in a language are alternate timelines
don’t have more information. Languages may also be superposed - this can either increase or decrease the number of possible timelines depending on what information is introduced.
Superposing in this asynchronous way can result in a set of strings (called a language) as
This occurs when there is some unresolved ambiguity. e.g. a b & a c = ? We don’t know the relation between b and c in this scenario. Superposition will generate a string for every possibility. The strings in a language are alternate timelines
don’t have more information. Languages may also be superposed - this can either increase or decrease the number of possible timelines depending on what information is introduced. In some cases it may also be possible to change the nature of our basic units to conflate a language with a single string...
The type of unit we treat as basic can have a significant impact on the complexity and accuracy of the strings.
The type of unit we treat as basic can have a significant impact on the complexity and accuracy of the strings. Three main options to consider: intervals, points, and semi-intervals.
The type of unit we treat as basic can have a significant impact on the complexity and accuracy of the strings. Three main options to consider: intervals, points, and semi-intervals. There is a translation to compress intervals to points, but the inverse is not possible. We can also translate intervals to semi-intervals, and the inverse is often (but not necessarily) possible.
Intervals have some duration.
Intervals have some duration. They can overlap, and so can be arranged in more ways than points can.
Intervals have some duration. They can overlap, and so can be arranged in more ways than points can. The thirteen possibilities for a pair of intervals are known as Allen Relations, after James Allen’s 1983 work.
Intervals have some duration. They can overlap, and so can be arranged in more ways than points can. The thirteen possibilities for a pair of intervals are known as Allen Relations, after James Allen’s 1983 work. Can be subdivided into smaller intervals if desired.
Intervals have some duration. They can overlap, and so can be arranged in more ways than points can. The thirteen possibilities for a pair of intervals are known as Allen Relations, after James Allen’s 1983 work. Can be subdivided into smaller intervals if desired. Used in annotation systems such as TimeML:
<TLINK relType="IS_INCLUDED" timeID="t1" relatedToEventInstance="ei9"/>
Intervals have some duration. They can overlap, and so can be arranged in more ways than points can. The thirteen possibilities for a pair of intervals are known as Allen Relations, after James Allen’s 1983 work. Can be subdivided into smaller intervals if desired. Used in annotation systems such as TimeML:
<TLINK relType="IS_INCLUDED" timeID="t1" relatedToEventInstance="ei9"/>
Interestingly, the thirteen relations fall out of superposing two strings that each feature a single interval.
Allen’s Interval Algebra a b & = a b b a a b b a a b a, b b a a, b b b a, b a a a, b b a, b a a, b b a, b a a, b a, b
Allen’s Interval Algebra a b & = a b b a a b b a a b a, b b a a, b b b a, b a a a, b b a, b a a, b b a, b a a, b a, b
Border boxes show that the interval is finite
Durationless points are an alternative to intervals.
Durationless points are an alternative to intervals. A pair of points can only be arranged in three ways: before, equals, after.
Durationless points are an alternative to intervals. A pair of points can only be arranged in three ways: before, equals, after. Fewer possible arrangements means fewer
Durationless points are an alternative to intervals. A pair of points can only be arranged in three ways: before, equals, after. Fewer possible arrangements means fewer
Lower complexity, but at the cost of accuracy…
Durationless points are an alternative to intervals. A pair of points can only be arranged in three ways: before, equals, after. Fewer possible arrangements means fewer
Lower complexity, but at the cost of accuracy… For example, “During breakfast, I ate cereal, then ate toast.”
Durationless points are an alternative to intervals. A pair of points can only be arranged in three ways: before, equals, after. Fewer possible arrangements means fewer
Lower complexity, but at the cost of accuracy… For example, “During breakfast, I ate cereal, then ate toast.” Breakfast and cereal-eating are treated as concurrent: b, c
Durationless points are an alternative to intervals. A pair of points can only be arranged in three ways: before, equals, after. Fewer possible arrangements means fewer
Lower complexity, but at the cost of accuracy… For example, “During breakfast, I ate cereal, then ate toast.” Breakfast and cereal-eating are treated as concurrent: b, c As are breakfast and toast-eating: b, t
Durationless points are an alternative to intervals. A pair of points can only be arranged in three ways: before, equals, after. Fewer possible arrangements means fewer
Lower complexity, but at the cost of accuracy… For example, “During breakfast, I ate cereal, then ate toast.” Breakfast and cereal-eating are treated as concurrent: b, c As are breakfast and toast-eating: b, t But cereal-eating is before toast-eating: c t
Durationless points are an alternative to intervals. A pair of points can only be arranged in three ways: before, equals, after. Fewer possible arrangements means fewer
Lower complexity, but at the cost of accuracy… For example, “During breakfast, I ate cereal, then ate toast.” Breakfast and cereal-eating are treated as concurrent: b, c As are breakfast and toast-eating: b, t But cereal-eating is before toast-eating: c t These three strings are not mutually consistent, as the durative nature has been lost.
What are semi-intervals?
What are semi-intervals? Neither point, nor interval (per se).
What are semi-intervals? Neither point, nor interval (per se). Defined as “beginnings and endings of events” (Freksa, 1992), i.e. the borders.
What are semi-intervals? Neither point, nor interval (per se). Defined as “beginnings and endings of events” (Freksa, 1992), i.e. the borders. Allows us to look at more complex relations between events, including ambiguity.
What are semi-intervals? Neither point, nor interval (per se). Defined as “beginnings and endings of events” (Freksa, 1992), i.e. the borders. Allows us to look at more complex relations between events, including ambiguity. Strings based on semi-intervals are also more complex (twice as many symbols).
What are semi-intervals? Neither point, nor interval (per se). Defined as “beginnings and endings of events” (Freksa, 1992), i.e. the borders. Allows us to look at more complex relations between events, including ambiguity. Strings based on semi-intervals are also more complex (twice as many symbols). Can describe two events as starting simultaneously, without commenting on which ends first (head to head).
What are semi-intervals? Neither point, nor interval (per se). Defined as “beginnings and endings of events” (Freksa, 1992), i.e. the borders. Allows us to look at more complex relations between events, including ambiguity. Strings based on semi-intervals are also more complex (twice as many symbols). Can describe two events as starting simultaneously, without commenting on which ends first (head to head). l(e1) = l(e2), r(e1) < or = or > r(e2)
What are semi-intervals? Neither point, nor interval (per se). Defined as “beginnings and endings of events” (Freksa, 1992), i.e. the borders. Allows us to look at more complex relations between events, including ambiguity. Strings based on semi-intervals are also more complex (twice as many symbols). Can describe two events as starting simultaneously, without commenting on which ends first (head to head). l(e1) = l(e2), r(e1) < or = or > r(e2) l(e1), l(e2) r(e1) r(e2) l(e1), l(e2) r(e1), r(e2) l(e1), l(e2) r(e2) r(e1) OR OR
What are semi-intervals? Neither point, nor interval (per se). Defined as “beginnings and endings of events” (Freksa, 1992), i.e. the borders. Allows us to look at more complex relations between events, including ambiguity. Strings based on semi-intervals are also more complex (twice as many symbols). Can describe two events as starting simultaneously, without commenting on which ends first (head to head). l(e1) = l(e2), r(e1) < or = or > r(e2) l(e1), l(e2) l(e1), l(e2) l(e1), l(e2)
What are semi-intervals? Neither point, nor interval (per se). Defined as “beginnings and endings of events” (Freksa, 1992), i.e. the borders. Allows us to look at more complex relations between events, including ambiguity. Strings based on semi-intervals are also more complex (twice as many symbols). Can describe two events as starting simultaneously, without commenting on which ends first (head to head). l(e1) = l(e2), r(e1) < or = or > r(e2) l(e1), l(e2) l(e1), l(e2) l(e1), l(e2) The three alternatives boil down to the same string - an advantage over pure intervals.
Points Intervals Semi-intervals
e1 e2 e1 l(e1) r(e1) e2 l(e2) r(e2)
Each approach allows for different numbers of relations to be found between events.
Each approach allows for different numbers of relations to be found between events. Point-based: 3
Events are points:
< = >
Each approach allows for different numbers of relations to be found between events. Point-based: 3 Interval-based: 13
Events are points:
< = >
Events are intervals:
< m d o s f = fi si oi di mi >
Each approach allows for different numbers of relations to be found between events. Point-based: 3 Interval-based: 13 Semi-interval-based: 29
Events are points:
< = >
Events are intervals:
< m d o s f = fi si oi di mi >
Events are semi-intervals:
< m d o s f = fi si oi di mi > ob oc hh yc bc tt sc ys ol yo sb sv ct bd db ?
The “gold standard” for identifying events in text?
The “gold standard” for identifying events in text? Still human judgement.
The “gold standard” for identifying events in text? Still human judgement. The TimeBank corpus contains hundreds of documents manually annotated with TimeML.
The “gold standard” for identifying events in text? Still human judgement. Automatic systems are improving, though modern machine learning approaches have weaknesses. The TimeBank corpus contains hundreds of documents manually annotated with TimeML.
The “gold standard” for identifying events in text? Still human judgement. Automatic systems are improving, though modern machine learning approaches have weaknesses. The TimeBank corpus contains hundreds of documents manually annotated with TimeML. Even correctly identifying part-of-speech automatically is not completely solved!
The “gold standard” for identifying events in text? Still human judgement. Automatic systems are improving, though modern machine learning approaches have weaknesses. Combining an approach from classic semantics with a data-driven one? The TimeBank corpus contains hundreds of documents manually annotated with TimeML. Even correctly identifying part-of-speech automatically is not completely solved!
The “gold standard” for identifying events in text? Still human judgement. Automatic systems are improving, though modern machine learning approaches have weaknesses. Combining an approach from classic semantics with a data-driven one? The TimeBank corpus contains hundreds of documents manually annotated with TimeML. Even correctly identifying part-of-speech automatically is not completely solved! Focus on the temporal data while retaining a link to the bigger picture.
DRT - created by Hans Kamp (1981).
DRT - created by Hans Kamp (1981). A well-understood formal semantics framework for handling meaning.
DRT - created by Hans Kamp (1981). A well-understood formal semantics framework for handling meaning. Made up of structures (DRSs) which feature discourse referents (the entities involved) and DRS conditions which give info about the referents.
DRT - created by Hans Kamp (1981). A well-understood formal semantics framework for handling meaning. Made up of structures (DRSs) which feature discourse referents (the entities involved) and DRS conditions which give info about the referents. “A boy buys a book.” x y boy(x) book(y) buys(x, y)
DRT - created by Hans Kamp (1981). A well-understood formal semantics framework for handling meaning. Made up of structures (DRSs) which feature discourse referents (the entities involved) and DRS conditions which give info about the referents. “A boy buys a book.” x y boy(x) book(y) buys(x, y)
Boxer is a tool to generate DRSs from text (Bos, 2008, 2015), using an intermediate CCG.
Boxer is a tool to generate DRSs from text (Bos, 2008, 2015), using an intermediate CCG. Includes temporal information in its output.
Boxer is a tool to generate DRSs from text (Bos, 2008, 2015), using an intermediate CCG. Includes temporal information in its output. “France is conquering Belgium.”
Boxer is a tool to generate DRSs from text (Bos, 2008, 2015), using an intermediate CCG. Includes temporal information in its output. “France is conquering Belgium.”
equals includes
Boxer is a tool to generate DRSs from text (Bos, 2008, 2015), using an intermediate CCG. Includes temporal information in its output. “France is conquering Belgium.”
equals includes
Not the same as Allen’s Relations!
Boxer is a tool to generate DRSs from text (Bos, 2008, 2015), using an intermediate CCG. Includes temporal information in its output. We can determine the tense and aspect from this. “France is conquering Belgium.”
Boxer is a tool to generate DRSs from text (Bos, 2008, 2015), using an intermediate CCG. Includes temporal information in its output. We can determine the tense and aspect from this. By assuming that the document creation time is the “speech time”, we can build a Reichenbachian analysis of an event. “France is conquering Belgium.”
Boxer is a tool to generate DRSs from text (Bos, 2008, 2015), using an intermediate CCG. Includes temporal information in its output. We can determine the tense and aspect from this. By assuming that the document creation time is the “speech time”, we can build a Reichenbachian analysis of an event. “France is conquering Belgium.” Not perfect!
Reichenbach’s (1947) theory of tense and aspect is a well-known way of attaining those features from an ordering of three times: the event (E), a reference timepoint (R), and a speech timepoint (S).
Reichenbach’s (1947) theory of tense and aspect is a well-known way of attaining those features from an ordering of three times: the event (E), a reference timepoint (R), and a speech timepoint (S).
E < R < S Past Perfect “I had eaten by the end of the day.” E = R < S Simple Past “I watched the match.” E = R = S Simple Present “I see a dog.” S < R = E Simple Future “I will drive home this evening.”
Reichenbach’s (1947) theory of tense and aspect is a well-known way of attaining those features from an ordering of three times: the event (E), a reference timepoint (R), and a speech timepoint (S).
E < R < S Past Perfect “I had eaten by the end of the day.” E = R < S Simple Past “I watched the match.” E = R = S Simple Present “I see a dog.” S < R = E Simple Future “I will drive home this evening.”
The discussion of intervals and points arises here too - the progressive aspect is achieved by treating E as an interval. For example:
E0 < R = S < E1 Present Progressive “I’m reading a book”
Once we have the tense, aspect, and event from the Boxer output, we can construct a string based
Once we have the tense, aspect, and event from the Boxer output, we can construct a string based
“I saw the movie on Tuesday.” becomes something like
Once we have the tense, aspect, and event from the Boxer output, we can construct a string based
“I saw the movie on Tuesday.” becomes something like see(me, movie), tuesday now where see(me, movie) is E, tuesday is R, and now is S.
Once we have the tense, aspect, and event from the Boxer output, we can construct a string based
“I saw the movie on Tuesday.” becomes something like see(me, movie), tuesday now where see(me, movie) is E, tuesday is R, and now is S. If the reference time is not explicit (e.g. just “I saw the movie”), an implicit fluent ref is inserted (though we typically omit it from the final output).
Once we have the tense, aspect, and event from the Boxer output, we can construct a string based
“I saw the movie on Tuesday.” becomes something like see(me, movie), tuesday now where see(me, movie) is E, tuesday is R, and now is S. If the reference time is not explicit (e.g. just “I saw the movie”), an implicit fluent ref is inserted (though we typically omit it from the final output). This string can then be superposed with other strings from the same text to build up timelines.
1. Raw text
1. Raw text 2. Tokeniser
1. Raw text 2. Tokeniser 3. POS-labelling
1. Raw text 2. Tokeniser 3. POS-labelling 4. Parsed by Boxer’s CCG
1. Raw text 2. Tokeniser 3. POS-labelling 4. Parsed by Boxer’s CCG 5. Interpreted by Boxer
1. Raw text 2. Tokeniser 3. POS-labelling 4. Parsed by Boxer’s CCG 5. Interpreted by Boxer 6. Parsed for temporal information
1. Raw text 2. Tokeniser 3. POS-labelling 4. Parsed by Boxer’s CCG 5. Interpreted by Boxer 6. Parsed for temporal information 7. String formed using Reichenbachian analysis
1. Raw text 2. Tokeniser 3. POS-labelling 4. Parsed by Boxer’s CCG 5. Interpreted by Boxer 6. Parsed for temporal information 7. String formed using Reichenbachian analysis 8. String superposed with any other strings already found*
*Only if the strings share some vocabulary!
1. Raw text 2. Tokeniser 3. POS-labelling 4. Parsed by Boxer’s CCG 5. Interpreted by Boxer 6. Parsed for temporal information 7. String formed using Reichenbachian analysis 8. String superposed with any other strings already found* 9. Timeline(s) produced
*Only if the strings share some vocabulary!
“Jim retired, and now he travels to London. He’ll have fun.”
A Tiny Example
Boxer output
A Tiny Example
Boxer output?
A Tiny Example
Actual Boxer output...
A Tiny Example
Actual Boxer output... There are still some steps to work through...
Using the sliiiightly modified text “Jim retired. Jim travels to London. Jim will have fun.” we get a better
retire(jim), ref1 now travel(jim, london), ref2, now now haveFun(jim), ref3
Finally we superpose these strings to give an output (omitting the reference times): retire(jim) travel(jim, london), now haveFun(jim)
Automatic summarisation of a document
Automatic summarisation of a document Fact-checking via corroboration between sources
Automatic summarisation of a document Fact-checking via corroboration between sources Tooling for automatic aiding of annotation (e.g. consistency-checking)
Automatic summarisation of a document Fact-checking via corroboration between sources Tooling for automatic aiding of annotation (e.g. consistency-checking) Question-answering systems which rely on temporal info (“What was the employee doing during the last inspection?”)
Automatic summarisation of a document Fact-checking via corroboration between sources Tooling for automatic aiding of annotation (e.g. consistency-checking) Question-answering systems which rely on temporal info (“What was the employee doing during the last inspection?”) The current implementation has also been used to solve problems in non-temporal domains - for example, the Zebra Puzzle (aka the Einstein Puzzle)
What are we still working on?
What are we still working on? Evaluating the choice of basic units (intervals, points, semi-intervals) - using a combined approach?
What are we still working on? Evaluating the choice of basic units (intervals, points, semi-intervals) - using a combined approach? Developing out the pipeline
What are we still working on? Evaluating the choice of basic units (intervals, points, semi-intervals) - using a combined approach? Developing out the pipeline Evaluation of Boxer-based output compared to human annotation-based output
Any questions? dwoods@tcd.ie
Slides available here: https://www.scss.tcd.ie/~dwoods/dclrs1119