1. Temporal Expression Recognition

Temporal Expression Recognition (TER) is the process of locating phrases that denote temporal information. Temporal expressions may be an expressed point in time, a duration or a frequency. 

These expressions can be used in information extraction and question-answering to (a) answer time-specific queries, (b) arrange information in a chronological manner, etc. Research in TER mostly exists in news domain text, arguably because of availability of large corpora and presence of temporal expressions in news documents. In recent times, TER has also been applied to other domains like medical (Sohn et al., 2013), (Jindal and Roth, 2013), (Xu et al., 2013), (Roberts et al., 2013). Initially, temporal expressions were considered a type of named entities and their identification was part of the named entity recognition task. Since the Automatic Content Extraction program1 in 2004 there has been a separate task identified and called Temporal Expression Recognition and Normalisation (TERN). Timex evaluation is now evaluated in two major temporal annotation challenges: TempEval2 and i2b23 , both of which prefer the TimeML-level TIMEX3 standard. Recently, Temporal Expression Recognition was a track in Clinical TempEval of SemEval 20154 challenge. It aims at extracting temporal information from clinical notes and pathology reports for cancer patients from the Mayo Clinic.

2. Event Extraction

Event extraction is a sub-problem of Knowledge Extraction which aims to extracts meaningful information called events in the form of situations, occurrences, action, circumstances etc from raw text. Events are also categorized into semantic classes based on their temporal behavior. Extraction of events and its semantic classes requires deeper understanding of syntactic and semantic information of the text.

3. Content 

Events And Temporal Expressions Part-I

Events And Temporal Expressions Part-II

Events And Temporal Expressions Part-III

Introduction to Events

The e language provides temporal constructs for specifying and verifying behavior over time. All e temporal language features depend on the occurrence of events, which are used to synchronize activity with a simulator and within the e program.

• If a path is provided, use the event defined in the struct instance pointed to by the path.
• If no path is provided, the event is resolved at compile time. The current struct instance is searched.
• If the event instance is not found, a compile-time error shall be issued.
  An event named "clk" is defined to be the rising edge of a signal named "top.clk" at another event named "sim". The @ symbol is used with an event name, @event, to mean "when the event is true". The special @sim syntax means at a callback from the simulator. The rise() expression always causes a callback when the signal rises. Therefore, this event definition means "a rise of top.clk causes clk to occur". Occurrences of the "clk" event are represented by arrows.

Defining and Emitting Named Events

Events are defined as a part of a struct definition. When a struct is instantiated, each instance has its own event instances. Each event instance has its own schedule of occurrences. There is no relation between occurrences of event instances of the same type. All references to events are to event instances. The scoping rules for events are similar to other struct members, such as fields.

Events can be attached to temporal expressions, using the option is [only] temporal-expression syntax, or they can be unattached. An attached event is emitted automatically during any tick in which the temporal expression attached to it succeeds.

You can use the emit action in any method to cause an event to occur, whether it has an attached temporal expression or not. The simplest usage of emit is to synchronize two TCMs, where one TCM waits for the named event and the other TCM emits it. Emitting an event causes the immediate evaluation of all temporal expressions that contain that event.

Example - Defining and Emitting Named Events

  1 <'

  2 struct eventEmit {

  3   event clk is rise('top.clk') @sim;;

  4   event nclk is fall('top.clk') @sim;

  5   event startSim;

  6

  7   mainInit()@clk is {

  8    // Do something here

  9    wait [1] *cycle;

 10    // Emit event

 11    emit startSim;

 12    // Do something here

 13   };

 14 };

 15 '>

Sampling Events Overview

Events are used to define the points at which temporal expressions and TCMs are sampled. An event attached to a temporal expression becomes the sampling event for the temporal expression. The event is attached using the @sampling-event syntax:

temporal-expression @sampling-event

The temporal expression is evaluated at every occurrence of the sampling event. The sampling period is the time from after one sampling event up to and including the next sampling event. All event occurrences within the same sampling period are considered simultaneous. Multiple occurrences of a particular event within one sampling period are considered to be one occurrence of that event.

Predefined Events Overview

Predefined events are events which are already defined in e language, they get emitted at pre defined point of time.

sys.any

This event is a special event that defines the finest granularity of time. The occurrence of any event in the system causes an occurrence of the any event at the same tick. In stand-alone e program operation (that is, with no simulator attached), the sys.any event is the only one that occurs automatically. It typically is used as the clock for stand-alone operation.

1 <'

 2 extend sys {

 3     event clk is cycle @sys.any;

 4 };

 5 '>

sys.tick_start

This event is provided mainly for visualizing and debugging the program flow.

sys.tick_end

This event is provided mainly for visualizing and debugging the program flow. It also can be used to provide visibility into changes of values that are computed during the tick, such as the values of coverage items. 

session.start_of_test

  1 <'

  2 extend sys {

  3   event clk is cycle @sys.any;

  4   event watchdog is {@session.start_of_test; [100]}@clk;

  5   on watchdog {

  6     out("Watchdog triggered");

  7     stop_run();

  8   };

  9 };

 10 '>

session.end_of_test

This event is typically used to sample data at the end of the test. This event cannot be used in temporal expressions, as it is emitted after evaluation of temporal expression has been stopped. The on session. end_of_test struct member is typically used to prepare the data sampled at the end of the test. struct.quit

This only exists in structs that contain temporal members (events, on, expect, or TCMs). It is emitted when the struct's quit() method is called, to signal the end of time for the struct.

The first action executed during the check test phase is to emit the quit event for each struct that contains it. This event can be used to cause the evaluation of temporal expressions that contain the eventually temporal operator (and check for eventually temporal expressions that have not been satisfied).

sys.new_time

This event is emitted on every sys.any event in stand-alone operation (no simulator). When a simulator is being used, this event is emitted whenever a callback occurs and the attached simulator's time has changed since the previous callback

Introduction to Temporal Expressions

Temporal expressions provide a declarative way to describe temporal behavior. The e language provides a set of temporal operators and keywords that can be uses to construct temporal expressions. 

A temporal expression (TE) is a combination of events and temporal operators that describes behavior. A TE expresses temporal relationships between events, values of fields, variables, or other items during a test.

Temporal expressions are used to define the occurrence of events, specify sequences of events as checkers, and suspend execution of a thread until the given sequence of events occurs. Temporal expressions are only legal in the following constructs:

• wait and sync actions in time-consuming methods (TCMs)
• event definitions and expect or assume struct members.

TE can be used like assertions in HDL (PSL or SVA), so they can be used for checking protocols.

Sampling Event

A key step in determining the meaning of a temporal expression is to identify its sampling event. The sampling event for a TE is one of the following, in decreasing order of precedence.

• The sampling event specified with the binary @ operator.
• The sampling event inherited from the parent temporal expression.
• The sampling event of the TCM if the TE appears under a wait or sync action of that TCM.
• sys.any, if none of the above applies.

Temporal Operators and Constructs

This section describes the constructs you can use in temporal expressions. not

The not temporal expression succeeds if the evaluation of the subexpression does not succeed during the sampling period. Thus not TE succeeds on every occurrence of the sampling event if TE does not succeed.

fail

A fail succeeds whenever the temporal expression fails. If the temporal expression has multiple interpretations (for example, fail (TE1 or TE2)), the expression succeeds if and only if all the interpretations fail.

and

The temporal and succeeds when both temporal expressions start evaluating in the same sampling period, and succeed in the same sampling period.

or

The or temporal expression succeeds when either temporal expression succeeds.

An or operator creates a parallel evaluation for each of its subexpressions. It can create multiple successes for a single temporal expression evaluation.

{ exp ; exp }

The semicolon (;) sequence operator evaluates a series of temporal expressions over successive occurrences of a specified sampling event. Each temporal expression following a ";" starts evaluating in the sampling period following that in which the preceding temporal expression succeeded. The sequence succeeds whenever its final expression succeeds.

eventually

Used to indicate that the temporal expression should succeed at some unspecified time. Typically, eventually is used in an expect struct member to specify that a temporal expression is expected to succeed sometime before the quit event occurs for the struct.

[ exp ]

Repetition of a temporal expression is frequently used to describe cyclic or periodic temporal behavior. The [exp] fixed repeat operator specifies a fixed number of occurrences of the same temporal expression.

If the numeric expression evaluates to zero, the temporal expression succeeds immediately.

[ exp..exp ]

The first match repeat operator is only valid in a temporal sequence {TE; TE; TE}. The first match repeat expression succeeds on the first success of the match-expression between the lower and upper bounds specified for the repeat-expression.

First match repeat also enables specification of behavior over infinite sequences by allowing an infinite number of repetitions of the repeat-expression to occur before the match-expression succeeds.

 Bạn Có Đam Mê Với Vi Mạch hay Nhúng      -     Bạn Muốn Trau Dồi Thêm Kĩ Năng

Mong Muốn Có Thêm Cơ Hội Trong Công Việc

Và Trở Thành Một Người Có Giá Trị Hơn

Bạn Chưa Biết Phương Thức Nào Nhanh Chóng Để Đạt Được Chúng

Hãy Để Chúng Tôi Hỗ Trợ Cho Bạn. SEMICON