README.md

---
license: other
license_name: cc-by-nc-sa-3.0-annotations-pubmed-texts
license_link: https://creativecommons.org/licenses/by-nc-sa/3.0/
features:
  - name: input
    dtype: string
  - name: output
    dtype: json
  - name: schema
    list:
      - name: label
        dtype: string
      - name: description
        dtype: string
configs:
  - config_name: default
    data_files:
      - split: train
        path: data/mlee_train.jsonl
      - split: validation
        path: data/mlee_validation.jsonl
      - split: test
        path: data/mlee_test.jsonl
---

# MLEE (mneb format) — nested event extraction, **span-linked**

The Multi-Level Event Extraction corpus (Pyysalo et al., Bioinformatics 2012) converted into
the mneb `json_structures` event-extraction format. MLEE annotates biomedical events across
multiple levels of biological organisation — from molecular through cellular and tissue to
organism level — over PubMed abstracts on angiogenesis.

**This dataset keeps event-as-argument nesting.** A third of MLEE's argument links point at
another *event* rather than an entity, and prior conversions (including TextEE's) drop them.
Here they are kept **without leaving the flat mneb record shape**: every argument is a plain
`{role,text,start,end}` span, and an argument that points at an event carries that event's
*trigger* span. See [Event arguments](#event-arguments).

Char offsets are character-based and end-exclusive (`input[start:end] == text`).
One record = one MLEE document.

## Splits

The **official** MLEE partition is preserved.

| Split | Records | With events | Events |
|---|---:|---:|---:|
| train | 131 | 131 | 3,206 |
| validation | 44 | 44 | 1,102 |
| test | 87 | 87 | 2,132 |
| **Total** | **262** | **262** | **6,440** |

TextEE instead discards the official boundary and makes five random re-splits, so no number
reported on a TextEE split is directly comparable to this one.

## Record format

```jsonc
{
  "input":  "<document text>",
  "output": {"json_structures": {"<event_type>": [<event>, ...]}},
  "schema": []
}
```

An event is `{"trigger": {"text","start","end"}, "arguments": [<arg>, ...]}`. There is
nothing else: no `type` field on the event (its type is the `json_structures` key), and no
object nested inside an argument.

### Event arguments

Every argument has the same four keys, whether it points at an entity or at another event:

```jsonc
{"role": "Cause",  "text": "anti-VEGF neutralizing antibody", "start": 1705, "end": 1736}
{"role": "Theme",  "text": "stimulated",                     "start": 1611, "end": 1621}
```

The first is an entity mention. The second is an **event link**: `(1611, 1621)` is the trigger
span of a `Positive_regulation` event, which is listed at the top level of the same record.
This is how mneb expresses links generally — repeat the span, no ids (cf. `mneb/bc5cdr`, whose
relation `head`/`tail` repeat the entity spans).

Because a linked child must be reachable, **every** event appears at the top level, not only
the roots. To resolve links:

```python
def resolve(js):
    """Index every event by its trigger span, then read arguments as links where they match."""
    by_span = {}
    for etype, evs in js.items():
        for ev in evs:
            by_span.setdefault((ev["trigger"]["start"], ev["trigger"]["end"]), []).append((etype, ev))
    for etype, evs in js.items():
        for ev in evs:
            for a in ev["arguments"]:
                target = by_span.get((a["start"], a["end"]))      # None => entity mention
                yield etype, ev, a, target
```

A real example from `PMID-10586954` — *"The insulin-conditioned RPE cell media stimulated
capillary endothelial cell proliferation, an effect that was completely blocked by anti-VEGF
neutralizing antibody"*. Three top-level events; the `Theme` chain
`blocked → stimulated → proliferation` is the nesting:

```jsonc
"Negative_regulation": [{
  "trigger": {"text": "blocked", "start": 1694, "end": 1701},
  "arguments": [{"role": "Theme", "text": "stimulated", "start": 1611, "end": 1621},
                {"role": "Cause", "text": "anti-VEGF neutralizing antibody",
                 "start": 1705, "end": 1736}]}],
"Positive_regulation": [{
  "trigger": {"text": "stimulated", "start": 1611, "end": 1621},
  "arguments": [{"role": "Theme", "text": "proliferation", "start": 1649, "end": 1662}]}],
"Cell_proliferation": [{
  "trigger": {"text": "proliferation", "start": 1649, "end": 1662},
  "arguments": [{"role": "Theme", "text": "capillary endothelial cell",
                 "start": 1622, "end": 1648}]}]
```

A conversion that simply *dropped* event-valued arguments would say only that something was
blocked by an antibody, losing that what was blocked is the stimulation of proliferation.

### How faithful the span links are

- **Telling a link from an entity mention:** on MLEE, **0** of the 5,767 entity-valued
  arguments sit on a span that is also a trigger. The test "this argument's span matches a
  trigger span" therefore has no false positives here.
- **Telling *which* event a link points at:** 2,417 of the 2,832 links (**85.3%**) match
  exactly one event of the right type. The other 415 (14.7%) land on a trigger span shared by
  several same-type events, and the span cannot disambiguate them.
- Consequently 238 of the 6,678 raw `E` lines (3.6%) come out byte-identical to another entry
  of the same type and are **collapsed**, leaving 6,440 events. Those are exactly the parents
  that differed only in an unresolvable choice of child; keeping both copies would double-count
  in any set-based metric.

Everything else round-trips: the offset invariant holds on every span, and the set of emitted
`(type, trigger, role/span)` signatures equals the same set computed straight off the raw
standoff, for every document.

## Statistics

- **29 event types**, **14 role types** (role strings kept verbatim, so `Theme2`,
  `Participant2..4` and `Instrument2` are *not* collapsed into their base role).
- **8,599 raw argument links** = 5,767 entity-valued + 2,832 event-valued (**32.9%** of all
  argument links are event-to-event). After the collapse above the files hold **8,155 argument
  instances** = 5,660 entity spans + 2,495 span links.
- **2,260 events (33.9%)** take at least one event argument.
- Raw nesting depth histogram `{1: 4416, 2: 1981, 3: 269, 4: 10}` — **max depth 4**.
- Nesting is almost entirely driven by the three regulation types; the sole exception is
  `Planned_process`, which takes an event argument 9 times. Only `Theme` and `Cause` are ever
  event-linked.

**Note on event counts.** Two of the 6,678 raw `E` lines are byte-identical duplicate
annotations (`PMID-16076702` E28/E29 and `PMID-19540587` E11/E25 — same type, same trigger,
same arguments); they collapse under the same rule as everything else.

Full type/role inventory and nesting patterns: `mlee_label_summary.md`.
Browsable rendering: `mlee_vis.html` (open directly; data embedded, no server needed).

## How this was derived

Built from the `MLEE-1.0.2-rev1` standoff release (`standoff/full/*.{txt,ann}`), with the
official split membership taken from the filenames in
`standoff/{development/train, development/test, test/test}`:

1. Each document's `.ann` (a1 + a2 merged: entity mentions, event triggers and `E` event
   lines) is parsed into a single text-bound annotation map.
2. Each `E` line becomes an event grouped under its own type; `Role:T…` arguments become the
   entity's span and `Role:E…` arguments become the child event's **trigger** span. Both come
   out in the same `{role,text,start,end}` shape.
3. Every event is listed at the top level, so a linked child is always resolvable. Entries that
   are byte-identical under one event type are then collapsed.
4. Relation (`R`), equivalence (`*`) and attribute (`A`/`M`: Negation, Speculation) lines are
   **not** carried over. Event-type and role strings are kept verbatim.

Verification built into the converter: every emitted span is re-checked against the source
text (`input[start:end] == text`, 0 failures); the set of emitted `(type, trigger, role/span)`
signatures is compared against the same set computed straight off the raw standoff and is equal
for every document; and a link audit reports, for every event-valued argument, whether its
child is uniquely identifiable from the span (the numbers quoted above).

## Licence and terms of use

- **Annotations** are licensed under **Creative Commons BY-NC-SA 3.0**. This is a
  **non-commercial, share-alike** licence: derivative works must carry the same terms, and
  commercial use is not permitted. Please attribute by citing the paper below and linking to
  <http://www.nactem.ac.uk/MLEE/>.
- **Abstracts** are from PubMed, a database of the U.S. National Library of Medicine; see the
  [NLM copyright information](http://www.nlm.nih.gov/databases/download.html).

## Citation

```bibtex
@article{Pyysalo12mlee,
  author  = {Sampo Pyysalo and Tomoko Ohta and Makoto Miwa and Han-Cheol Cho and
             Jun'ichi Tsujii and Sophia Ananiadou},
  title   = {Event extraction across multiple levels of biological organization},
  journal = {Bioinformatics},
  volume  = {28},
  number  = {18},
  pages   = {i575--i581},
  year    = {2012}
}
```