#!/usr/bin/env python3 """ Run this script as ./conversion_script.py to convert the BioCause dataset DIRECTLY from its original brat-format annotation files, bypassing the CREST aggregation (crest_v2.xlsx). CREST's own copy of BioCause has (a) train only, 0 dev/test rows (a real CREST-source gap, not fixable by adjusting causalatee's split logic), and (b) the same idx/context character-offset misalignment already found and fixed for CaTeRS, dropping some spans on conversion. Citation / original source --------------------------- Mihaila, C., Ohta, T., Pyysalo, S., & Ananiadou, S. (2013). "BioCause: Annotating and analysing causality in the biomedical domain." BMC Bioinformatics, 14, 2. https://doi.org/10.1186/1471-2105-14-2 Corpus home: https://www.nactem.ac.uk/biocause/ Direct download (verified working, no login): a zip archive at https://www.nactem.ac.uk/biocause/download-biocause-corpus.php containing one BioCause_corpus/ directory of paired .ann/.txt files (brat standoff), one pair per section of a PMC Open-Access article's Discussion (also includes TIAB/Introduction/Results sections for some articles) -- 198 file pairs across 20 unique PMC article ids, verified directly. Format: brat standoff, built on top of a pre-existing BioNLP-ST 2011 Infectious Diseases event/entity layer in the SAME .ann files (Organism, Protein, Positive_regulation, Regulation, Gene_expression, ... -- ignored here, we only want the Causality layer). Causal relations are event-style: T Causality E Causality:T Cause:T Effect:T E Causality:T Effect:T Evidence:T (no Cause -- common) Cause/Effect/Evidence roles always reference a T-line directly (verified: grepped the whole corpus for a role pointing at another E-line -- none found), so no recursive event resolution is needed. ~18 T-line spans are discontinuous (semicolon-joined offset pairs) -- preserved via causalatee's multi-segment entity schema. Only 51 of 851 Causality events have an explicit Cause role; the other 800 have Effect+Evidence with NO separate cause span at all -- the causing participant is not marked as its own argument in those cases. Causality-DETECTION uses all 851 (a sentence is causal if it contains ANY Causality event, span or no span). Causal-candidate-extraction and causality-IDENTIFICATION need an explicit (cause, effect) span pair, so they only use the 51 Cause+Effect events -- a real, small, and worth documenting limitation of this corpus, not an artefact of this script. No train/dev/test split exists upstream (checked: no filename in the archive contains train/dev/test) -- CREST's own split was entirely invented. This script creates its own deterministic split BY ARTICLE (not by section) so sections of the same PMC article never end up split across train/dev/test: 14 articles -> train, 3 -> dev, 3 -> test. Only 7 of the 20 articles contain any of the 51 Cause+Effect relations at all (the other 13 have Effect+Evidence-only Causality events, which count for detection but not identification/extraction -- see below). A first version of this split just sorted article ids and sliced [:14]/[14:17]/ [17:20] -- deterministic, but blind to where those 51 relations actually live: alphabetically, ALL THREE of the last 3 article ids happen to be relation-free, so causality-IDENTIFICATION's test split silently ended up with 0 usable pairs (found the hard way: the dependency-baseline runner crashed with "BioCause has no usable identification pairs"). Fixed by `_assign_documents_to_splits`: a deterministic greedy assignment that places the 20 articles (sorted by relation count descending, ties by id) one at a time into whichever split is currently furthest below its target relation share (train/dev/test's 14/3/3 document-count ratio), so every split ends up with a reasonable, non-zero share of the 51 relations (currently 28/12/11) while whole articles still never cross a split boundary. Granularity: each row is a WHOLE SECTION (not a sentence). An earlier version of this script cut each section into per-sentence rows (spaCy boundaries, one row per sentence), but ~30 of BioCause's 851 Causality events have a cause and/or effect span that references an ADJACENT sentence rather than the one their trigger is in (discourse-level causality, e.g. "X requires Y... [new sentence] This substitution decreases Z") -- verified this really happens by inspecting real output. A per-sentence schema can't represent such an event at all: either drop it (losing ~30 real relations for no reason other than granularity) or re-base it onto the wrong sentence's text (a real bug hit during that attempt: a marker landing mid-word, "histidine"). Keeping the whole section as one unit sidesteps the tradeoff entirely -- every event's spans are always within the row's text, nothing is dropped or corrupted. The per-sentence view can still be derived on demand from this whole-section data via causalatee's reusable ``causalatee.data.utils.split_identification_to_sentences`` / ``split_extraction_to_sentences`` utilities -- built specifically to generalise the guard this script used to hand-roll. """ import io import re import urllib.request import zipfile from pathlib import Path import pandas as pd from causalatee.data.constants import ClassLabel, Relation, Task from causalatee.data.utils import insert_entity_markers, verify_dataset _ZIP_URL = "https://www.nactem.ac.uk/biocause/download-biocause-corpus.php" _CACHE_DIR = Path(__file__).parent / ".cache" def _fetch_corpus_dir() -> Path: """Download + extract the BioCause zip once, cached under .cache/.""" corpus_dir = _CACHE_DIR / "BioCause_corpus" if corpus_dir.is_dir() and any(corpus_dir.iterdir()): return corpus_dir _CACHE_DIR.mkdir(parents=True, exist_ok=True) with urllib.request.urlopen(_ZIP_URL) as resp: data = resp.read() with zipfile.ZipFile(io.BytesIO(data)) as zf: zf.extractall(_CACHE_DIR) return corpus_dir def _parse_ann(ann_text: str) -> tuple[dict[str, list[tuple[int, int]]], dict[str, str], list[dict]]: """Parse one .ann file. Returns (t_spans: T-line id -> segments, t_types: T-line id -> type, causality_events: list of {"trigger": tid, "cause": tid|None, "effect": tid|None} for every Causality-typed event). """ t_spans: dict[str, list[tuple[int, int]]] = {} t_types: dict[str, str] = {} for line in ann_text.splitlines(): if not line.startswith("T"): continue tid, mid, _ = (line.split("\t", 2) + [""])[:3] etype, offsets_str = mid.split(" ", 1) segments = [tuple(int(x) for x in pair.split()) for pair in offsets_str.split(";")] t_spans[tid] = sorted(segments) t_types[tid] = etype causality_events = [] for line in ann_text.splitlines(): if not line.startswith("E"): continue _, mid = line.split("\t", 1) roles = mid.strip().split(" ") trigger_role, trigger_tid = roles[0].split(":") if trigger_role != "Causality": continue args = dict(r.split(":") for r in roles[1:] if ":" in r) causality_events.append({ "trigger": trigger_tid, "cause": args.get("Cause"), "effect": args.get("Effect"), }) return t_spans, t_types, causality_events def _load_sections() -> list[dict]: """One dict per .ann/.txt pair: {"doc_id", "text", "events": [...]}.""" corpus_dir = _fetch_corpus_dir() sections = [] for ann_path in sorted(corpus_dir.glob("*.ann")): txt_path = ann_path.with_suffix(".txt") text = txt_path.read_text(encoding="utf-8") t_spans, _, events = _parse_ann(ann_path.read_text(encoding="utf-8")) doc_id = re.match(r"(PMC\d+)-", ann_path.stem).group(1) resolved = [ { "cause_segments": t_spans[e["cause"]] if e["cause"] else None, "effect_segments": t_spans[e["effect"]] if e["effect"] else None, } for e in events if e["effect"] in t_spans and (e["cause"] is None or e["cause"] in t_spans) ] sections.append({"doc_id": doc_id, "text": text, "events": resolved}) return sections def _load_rows() -> list[dict]: """One row per whole section, cached across the 3 convert_for_* calls. No sentence segmentation happens here at all -- every event's cause/effect segments are already within the section's own text by construction, so there is nothing to re-base and nothing to drop. """ if hasattr(_load_rows, "_cache"): return _load_rows._cache rows = [] for section in _load_sections(): segments: dict[str, list[tuple[int, int]]] = {} relations = [] for i, ev in enumerate(section["events"]): effect_id = f"e{2 * i + 1}" segments[effect_id] = ev["effect_segments"] if ev["cause_segments"] is not None: cause_id = f"e{2 * i + 2}" segments[cause_id] = ev["cause_segments"] relations.append({"relationship": Relation.Procausal, "first": cause_id, "second": effect_id}) rows.append({"doc_id": section["doc_id"], "text": section["text"], "relations": relations, "segments": segments}) _load_rows._cache = rows return rows _SPLIT_DOC_CAPACITY = {"train": 14, "dev": 3, "test": 3} def _assign_documents_to_splits(rows: list[dict]) -> dict[str, set[str]]: """Deterministic greedy split assignment, balanced by relation count. Sorts articles by their number of Cause+Effect relations (descending, ties broken by doc id), then assigns each one to whichever split still has capacity and is currently furthest below its target relation share (train/dev/test's document-count ratio) -- see module docstring for why a plain sorted-id slice isn't good enough here. """ doc_relations: dict[str, int] = {} for r in rows: doc_relations[r["doc_id"]] = doc_relations.get(r["doc_id"], 0) + len(r["relations"]) assigned: dict[str, set[str]] = {split: set() for split in _SPLIT_DOC_CAPACITY} rel_totals = {split: 0 for split in _SPLIT_DOC_CAPACITY} order = sorted(doc_relations, key=lambda d: (-doc_relations[d], d)) for doc_id in order: candidates = [s for s, cap in _SPLIT_DOC_CAPACITY.items() if len(assigned[s]) < cap] best = min(candidates, key=lambda s: (rel_totals[s] / _SPLIT_DOC_CAPACITY[s], -_SPLIT_DOC_CAPACITY[s])) assigned[best].add(doc_id) rel_totals[best] += doc_relations[doc_id] return assigned def _split_by_document(rows: list[dict], split: str) -> list[dict]: wanted = _assign_documents_to_splits(rows)[split] return [r for r in rows if r["doc_id"] in wanted] def convert_for_causality_detection(split: str) -> None: rows = _split_by_document(_load_rows(), split) df = pd.DataFrame([ { "index": f"biocause_{split}_{i}", "text": r["text"], "label": ClassLabel.Causal if r["relations"] or r["segments"] else ClassLabel.Uncausal, } for i, r in enumerate(rows) ]).set_index("index") for error in verify_dataset(df, Task.CausalityDetection): print(f"WARNING [BioCause {Task.CausalityDetection}/{split}]: {error}") df.to_parquet(f"./causality-detection/{split}.parquet", engine="pyarrow") def convert_for_causal_candidate_extraction(split: str) -> None: rows = _split_by_document(_load_rows(), split) out = [] for i, r in enumerate(rows): # Only entities that participate in a full Cause+Effect relation have a # usable pair; entities from Effect-only (no Cause) events are dropped # here (extraction needs no relation to exist, but we still restrict to # spans backing an actual relation, matching the other converters' # "only causal_eids" convention). involved = {eid for rel in r["relations"] for eid in (rel["first"], rel["second"])} entity = [[x for seg in r["segments"][eid] for x in seg] for eid in involved] out.append({"index": f"biocause_{split}_{i}", "text": r["text"], "entity": entity}) df = pd.DataFrame(out).set_index("index") for error in verify_dataset(df, Task.CausalCandidateExtraction): print(f"WARNING [BioCause {Task.CausalCandidateExtraction}/{split}]: {error}") df.to_parquet(f"./causal-candidate-extraction/{split}.parquet", engine="pyarrow") def convert_for_causality_identification(split: str) -> None: rows = _split_by_document(_load_rows(), split) out = [] for i, r in enumerate(rows): marked_text = insert_entity_markers(r["text"], r["segments"]) if r["segments"] else r["text"] out.append({"index": f"biocause_{split}_{i}", "text": marked_text, "relations": r["relations"]}) df = pd.DataFrame(out).set_index("index") for error in verify_dataset(df, Task.CausalityIdentification): print(f"WARNING [BioCause {Task.CausalityIdentification}/{split}]: {error}") df.to_parquet(f"./causality-identification/{split}.parquet", engine="pyarrow") if __name__ == "__main__": for split in ["train", "dev", "test"]: convert_for_causality_detection(split) convert_for_causal_candidate_extraction(split) convert_for_causality_identification(split)