Add PubMedCausal dataset (Adewole et al., arXiv 2605.28363)

.gitattributes

@@ -0,0 +1,59 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.pyc

README.md

@@ -0,0 +1,57 @@
+# PubMedCausal
+
+Causal relation extraction corpus from PubMed abstracts.
+
+**Paper:** Adewole et al. (2025). *PubMedCausal: A Biomedical Causal Relation Extraction Corpus.*
+arXiv:2605.28363
+
+**Source:** https://github.com/josiahpaul07/PubMedCausal_Exp
+
+## Statistics
+
+| Split | Sentences | Causal | Non-causal | Pairs |
+|-------|-----------|--------|------------|-------|
+| Train | 15,000    | 1,972  | 13,028     | ~3,900 |
+| Test  | 15,000    | 1,973  | 13,027     | ~2,600 |
+
+Pairs are typed along two dimensions:
+- **Causality:** Explicit / Implicit
+- **Sententiality:** Intra-sentential / Inter-sentential
+
+No countercausal annotations — all relations map to `Relation.Procausal`.
+
+## Conversion
+
+Data is fetched directly from GitHub at conversion time; no local download is needed.
+
+```bash
+python conversion_script.py
+```
+
+Produces three task parquets per split under this directory:
+
+```
+causality-detection/
+causal-candidate-extraction/
+causality-identification/
+```
+
+## Known limitation — unresolvable spans in the identification task
+
+PubMedCausal sometimes records the **canonical / normalised form** of a span rather
+than the exact surface text from the sentence. For example:
+
+```
+sentence: "...thus precluding practice and placebo effects..."
+effect annotation: "precludes practice"   ← lemmatised, does not match
+```
+
+Because the identification task requires inserting `<e1>…</e1>` markers at exact
+character positions, pairs where either span cannot be located verbatim are
+**skipped** during conversion. The conversion script prints a warning for each
+skipped pair and a summary count at the end.
+
+This affects **1,078 train pairs and 997 test pairs** (roughly 28% of intra-sentential
+pairs), predominantly Implicit-causality annotations where the annotator wrote the
+inferred proposition rather than the surface string. The detection and extraction
+tasks are unaffected.

causal-candidate-extraction/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d65538c601ea00d446b7278253f5f2b417d6094582643dfb5a403c6abf75e39
+size 390911

causal-candidate-extraction/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:44be6164e44111693bd607ef0db3d7411a595cf7eea43d7615982e0c3e05db93
+size 395699

causality-detection/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c49989d5dd782d478922b311e6831cf2bbedef8ce0a1dad5ed14ab370f8c9393
+size 2640494

causality-detection/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e17f4f2f5516342b8bf2c3d7b967b41cfaa93a9302b2c554cf02dfb0fae4adbf
+size 2652258

causality-identification/test.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ff6c2f29a7f89010fe06e7497e41341fc52206f4e0a9f747f8bb00657ef7393
+size 307507

causality-identification/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:74f72ebb25ae506b838b5f85c0f0ad0b45d921e94e4a2c8edbdff43f3b2abddb
+size 312738

conversion_script.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+
+"""
+Convert PubMedCausal to HF-compatible parquet files, loading data directly from GitHub.
+
+PubMedCausal (Adewole et al., 2025; arXiv:2605.28363):
+  30K paragraph-level rows from PubMed abstracts; 3,945 causal sentences with
+  6,491 annotated cause-effect pairs. Pairs are typed as Explicit/Implicit and
+  Intra/Inter-sentential. No countercausal labels.
+
+Source files (fetched at runtime — no local download needed):
+  Detection:  detection_train.json / detection_test.json
+              {"s/n": int, "sentence": str, "label": 0|1}
+  Extraction: extraction_combined/train.json / extraction_combined/test.json
+              {"s/n": int, "sentence": str, "pairs": [{"cause", "effect",
+               "sententiality", "causality"}], "num_pairs": int}
+
+Note: inter-sentential pairs (sententiality="Inter") are included in detection
+and extraction but skipped for identification, as cause and effect may not
+both appear in the single sentence string.
+"""
+
+import json
+import urllib.request
+from pathlib import Path
+
+import pandas as pd
+
+from ctk.data.constants import ClassLabel, Relation, Task
+from ctk.data.conversion._converter import FormatConverter
+
+_BASE = "https://raw.githubusercontent.com/josiahpaul07/PubMedCausal_Exp/main/PUBMEDCAUSAL/data/prepared"
+
+_DETECTION_URLS = {
+    "train": f"{_BASE}/detection_train.json",
+    "test": f"{_BASE}/detection_test.json",
+}
+
+_EXTRACTION_URLS = {
+    "train": f"{_BASE}/extraction_combined/train.json",
+    "test": f"{_BASE}/extraction_combined/test.json",
+}
+
+
+def _fetch(url: str) -> list[dict]:
+    with urllib.request.urlopen(url) as resp:
+        return json.load(resp)
+
+
+def _find_span(text: str, span: str) -> tuple[int, int] | None:
+    """Return (start, end) of span in text; case-insensitive fallback."""
+    idx = text.find(span)
+    if idx == -1:
+        idx = text.lower().find(span.lower())
+    return (idx, idx + len(span)) if idx != -1 else None
+
+
+class PubMedCausal2HF(FormatConverter):
+    def __init__(self, target: Path) -> None:
+        super().__init__(target)
+
+    def _convert(self, task: str, split: str) -> pd.DataFrame:
+        dispatch = {
+            Task.CausalityDetection: self._convert_detection,
+            Task.CausalCandidateExtraction: self._convert_extraction,
+            Task.CausalityIdentification: self._convert_identification,
+        }
+        return dispatch[task](split)
+
+    def _convert_detection(self, split: str) -> pd.DataFrame:
+        rows = [
+            {"index": f"pubmedcausal_{r['s/n']}", "text": r["sentence"], "label": int(r["label"])}
+            for r in _fetch(_DETECTION_URLS[split])
+        ]
+        return pd.DataFrame(rows).set_index("index")
+
+    def _convert_extraction(self, split: str) -> pd.DataFrame:
+        rows = []
+        for rec in _fetch(_EXTRACTION_URLS[split]):
+            text = rec["sentence"]
+            seen: set[tuple[int, int]] = set()
+            spans: list[list[int]] = []
+            for pair in rec.get("pairs", []):
+                for span_text in (pair["cause"], pair["effect"]):
+                    offsets = _find_span(text, span_text)
+                    if offsets and offsets not in seen:
+                        seen.add(offsets)
+                        spans.append(list(offsets))
+            rows.append({"index": f"pubmedcausal_{rec['s/n']}", "text": text, "entity": spans})
+        return pd.DataFrame(rows).set_index("index")
+
+    def _convert_identification(self, split: str) -> pd.DataFrame:
+        rows = []
+        skipped_pairs = 0
+        for rec in _fetch(_EXTRACTION_URLS[split]):
+            text = rec["sentence"]
+            intra = [p for p in rec.get("pairs", []) if p.get("sententiality") == "Intra"]
+            if not intra:
+                continue
+
+            # Only keep pairs where both spans can be located verbatim in the sentence.
+            # PubMedCausal sometimes records canonical/normalised span text that differs
+            # from the surface form (e.g. "precludes X" vs "precluding X"), making exact
+            # insertion of entity markers impossible. Such pairs are dropped here and
+            # counted in the summary printed after conversion.
+            resolvable = []
+            for pair in intra:
+                cause_loc = _find_span(text, pair["cause"])
+                effect_loc = _find_span(text, pair["effect"])
+                if cause_loc is None or effect_loc is None:
+                    skipped_pairs += 1
+                    print(
+                        f"  [skip] s/n={rec['s/n']}: span not found in sentence\n"
+                        f"    cause:  {pair['cause']!r}\n"
+                        f"    effect: {pair['effect']!r}\n"
+                        f"    sentence: {text!r}",
+                        flush=True,
+                    )
+                    continue
+                resolvable.append((pair, cause_loc, effect_loc))
+
+            if not resolvable:
+                continue
+
+            # Assign stable entity IDs to the resolved spans only.
+            span_to_id: dict[str, int] = {}
+            for pair, _, __ in resolvable:
+                for span_text in (pair["cause"], pair["effect"]):
+                    if span_text not in span_to_id:
+                        span_to_id[span_text] = len(span_to_id) + 1
+
+            relations = [
+                {
+                    "relationship": int(Relation.Procausal),
+                    "first": f"e{span_to_id[p['cause']]}",
+                    "second": f"e{span_to_id[p['effect']]}",
+                }
+                for p, _, __ in resolvable
+            ]
+
+            located: list[tuple[int, int, str]] = [
+                (*offsets, f"e{span_to_id[span_text]}")
+                for span_text, offsets in (
+                    (p["cause"], cause_loc) for p, cause_loc, _ in resolvable
+                )
+            ] + [
+                (*offsets, f"e{span_to_id[span_text]}")
+                for span_text, offsets in (
+                    (p["effect"], effect_loc) for p, _, effect_loc in resolvable
+                )
+            ]
+            # Deduplicate (same span may appear in multiple pairs).
+            seen_locs: set[tuple[int, int]] = set()
+            unique_located = []
+            for start, end, tag in located:
+                if (start, end) not in seen_locs:
+                    seen_locs.add((start, end))
+                    unique_located.append((start, end, tag))
+
+            marked = text
+            for start, end, tag in sorted(unique_located, key=lambda x: x[0], reverse=True):
+                marked = marked[:start] + f"<{tag}>" + marked[start:end] + f"</{tag}>" + marked[end:]
+
+            rows.append({"index": f"pubmedcausal_{rec['s/n']}", "text": marked, "relations": relations})
+
+        if skipped_pairs:
+            print(f"  [{split}] skipped {skipped_pairs} pair(s) where a span could not be located in the sentence.")
+
+        if not rows:
+            return pd.DataFrame(columns=["text", "relations"]).rename_axis("index")
+        return pd.DataFrame(rows).set_index("index")
+
+
+if __name__ == "__main__":
+    here = Path(__file__).parent
+    converter = PubMedCausal2HF(here)
+
+    for split in ("train", "test"):
+        print(f"Converting {split}...")
+        converter.convert(Task.CausalityDetection, split)
+        converter.convert(Task.CausalCandidateExtraction, split)
+        converter.convert(Task.CausalityIdentification, split)
+
+    print("\nDone. Parquet files written to:")
+    for task in ("causality-detection", "causal-candidate-extraction", "causality-identification"):
+        for split in ("train", "test"):
+            p = here / task / f"{split}.parquet"
+            if p.exists():
+                df = pd.read_parquet(p)
+                print(f"  {p.relative_to(here)}  ({len(df):,} rows)")