Skip to content

Relation and Event Extraction

How to annotate relations between entities and structured events with triggers and arguments, using span linking and event annotation in Potato.

Relation extraction connects two entities with a typed link ("Marie Curie, won, Nobel Prize"). Event extraction goes further: it marks an event trigger and the roles around it (who did what, to whom, when). Both turn flat text into structured knowledge.

See Relationship extraction and Event extraction for background.

Relations: linking spans

A relation annotation has three parts: a head span, a tail span, and a relation type. In Potato, annotators first mark the spans, then draw a directed, typed link between them (span linking).

yaml
annotation_schemes:
  - annotation_type: span
    name: entities
    description: "Mark the entities involved."
    labels: [PERSON, ORGANIZATION, AWARD]
  - annotation_type: span_link
    name: relations
    description: "Draw a link between two entities and choose the relation."
    span_schema: entities
    link_types:
      - name: WON
        directed: true
        allowed_source_labels: [PERSON]
        allowed_target_labels: [AWARD]
      - name: AFFILIATED_WITH
        directed: true
        allowed_source_labels: [PERSON]
        allowed_target_labels: [ORGANIZATION]

span_schema names the span scheme whose spans can be linked, and each entry in link_types constrains which labels may sit at each end, so an annotator cannot draw a relation the schema does not allow. Relations are directional, so decide and document the direction of each type (is it "founded_by" pointing from company to person, or the reverse?).

Events: triggers and arguments

An event is anchored by a trigger word (often a verb like "acquired") and has arguments filling typed roles (Buyer, Seller, Price, Date). Potato's event annotation type lets annotators mark the trigger and attach role-labeled spans.

The event annotation showcase demonstrates a working trigger-and-argument setup.

Why these tasks are hard

  • The label space is large, so agreement drops. Keep relation and role types few and well-defined.
  • Annotators must first get the spans right; errors compound. Consider annotating entities in a first pass and relations in a second.
  • Structured output makes agreement metrics non-trivial, measure at the level you care about (correct trigger, correct argument, correct full event).

Further reading