Create simord_hf_loader.py

simord_hf_loader.py

@@ -0,0 +1,268 @@
+# simord_hf_loader.py
+# HF Datasets loader that uses mediqa-oe.data.process_data.attach_transcript_section
+# to merge transcripts into local annotations: train, test1, test2.
+#
+# Dataset license: CDLA-2.0-permissive (for SIMORD). Respect upstream source licenses.
+#
+# Requirements:
+#   pip install datasets nltk requests
+#   pip install -e /path/to/mediqa-oe   # or add repo to PYTHONPATH
+#
+# Usage:
+#   from datasets import load_dataset
+#   ds = load_dataset(
+#       "path/to/simord_hf_loader.py",
+#       data_dir="path/to/annotations_dir",  # with train.json, test1.json, test2.json (lists of dicts)
+#   )
+#   print(ds)
+#
+# The loader will auto-download ACI-Bench and PriMock57 from GitHub to create transcript_dict.
+
+import json
+import os
+import re
+from typing import Dict, Iterable, List, Tuple
+
+import datasets
+import nltk
+
+# Ensure sentence tokenizer needed by mediqa-oe code is available
+try:
+    nltk.data.find("tokenizers/punkt_tab")
+except LookupError:
+    nltk.download("punkt_tab")
+
+# ---- Import the exact merge function from your repo ----
+# (Relies on your local mediqa-oe being importable)
+from mediqa_oe.data.process_data import attach_transcript_section  # noqa: E402
+
+# ---- Sources (same as your script) ----
+ACI_BENCH_URL = "https://github.com/wyim/aci-bench/archive/refs/heads/main.zip"
+PRIMOCK_URL = "https://github.com/babylonhealth/primock57/archive/refs/heads/main.zip"
+
+_DESCRIPTION = """\
+SIMORD loader that merges transcripts from ACI-Bench and PriMock57 into local annotations
+using mediqa-oe.data.process_data.attach_transcript_section.
+"""
+_CITATION = r"""@article{corbeil2025empowering,
+  title={Empowering Healthcare Practitioners with Language Models: Structuring Speech Transcripts in Two Real-World Clinical Applications},
+  author={Corbeil, Jean-Philippe and Ben Abacha, Asma and Michalopoulos, George and Swazinna, Patrick and Del-Agua, Miguel and Tremblay, Julien and Jeeson Daniel, Aju and Bader, Corey and Cho, Yoon-Chan and Krishnan, Parvathi and Bodenstab, Nathan and Lin, Tony and Teng, Wen and Beaulieu, Francois and Vozila, Paul},
+  journal={arXiv preprint arXiv:2507.05517},
+  year={2025}
+}"""
+_LICENSE = "CDLA-2.0-permissive"
+_HOMEPAGE = "https://huggingface.co/datasets/<your-org>/SIMORD"
+
+# ----------------------- helpers to read upstream transcripts -----------------------
+
+def _walk_json_files(directory: str) -> List[str]:
+    out = []
+    for d, _, files in os.walk(directory):
+        for fn in files:
+            if fn.lower().endswith(".json"):
+                out.append(os.path.join(d, fn))
+    out.sort()
+    return out
+
+def _read_json_records(path: str) -> Iterable[dict]:
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    if isinstance(data, dict) and "data" in data and isinstance(data["data"], list):
+        for r in data["data"]:
+            yield r
+    elif isinstance(data, list):
+        for r in data:
+            yield r
+    else:
+        # single dict record
+        yield data
+
+def _normalize_id_from_aci(file_field: str, basename: str) -> str:
+    # matches your script:
+    # file_id = "_".join(d.get("file", "").split("-")[0:2])
+    # transcript_id = "acibench_" + file_id + "_" + basename
+    file_id = "_".join((file_field or "").split("-")[0:2])
+    return f"acibench_{file_id}_{basename}"
+
+def _build_aci_transcript_dict(root: str) -> Dict[str, dict]:
+    """
+    Mirror of read_aci_bench_data + walk_aci_bench_directory:
+      looks in .../aci-bench-main/data/challenge_data_json and .../src_experiment_data_json
+      and builds {transcript_id: {"transcript": <src_text>}}
+    """
+    tdict: Dict[str, dict] = {}
+    base = None
+    # Find the 'aci-bench-main' folder inside root
+    for name in os.listdir(root):
+        if name.startswith("aci-bench"):
+            base = os.path.join(root, name)
+            break
+    if not base:
+        return tdict
+
+    for sub in ("data/challenge_data_json", "data/src_experiment_data_json"):
+        p = os.path.join(base, sub)
+        if not os.path.isdir(p):
+            continue
+        for fp in _walk_json_files(p):
+            basename = os.path.splitext(os.path.basename(fp))[0]
+            for rec in _read_json_records(fp):
+                src = rec.get("src")
+                file_field = rec.get("file", "")
+                tid = _normalize_id_from_aci(file_field, basename)
+                if src:
+                    tdict[tid] = {"transcript": src}
+    return tdict
+
+def _read_text(path: str) -> str:
+    with open(path, "r", encoding="utf-8") as f:
+        return f.read()
+
+def _normalize_primock_id(stem: str) -> str:
+    # replicate replacements used in your script:
+    # primock_id = filename.replace("day", "primock57_")
+    # primock_id = primock_id.replace("consultation0", "")
+    # primock_id = primock_id.replace("consultation", "")
+    s = stem
+    s = s.replace("day", "primock57_")
+    s = s.replace("consultation0", "")
+    s = s.replace("consultation", "")
+    return s
+
+def _build_primock_transcript_dict(root: str) -> Dict[str, dict]:
+    """
+    Mirror of read_primock_data post-conversion:
+      reads *.txt in primock57-main/transcripts and applies the same tag normalization.
+    """
+    tdict: Dict[str, dict] = {}
+    base = None
+    for name in os.listdir(root):
+        if name.startswith("primock57"):
+            base = os.path.join(root, name)
+            break
+    if not base:
+        return tdict
+
+    tx_dir = os.path.join(base, "transcripts")
+    if not os.path.isdir(tx_dir):
+        # If transcripts haven't been generated yet by upstream script, we skip.
+        return tdict
+
+    for fn in os.listdir(tx_dir):
+        if not fn.lower().endswith(".txt"):
+            continue
+        fp = os.path.join(tx_dir, fn)
+        lines = [ln.strip() for ln in _read_text(fp).splitlines() if ln.strip()]
+        norm = []
+        for line in lines:
+            line = line.replace("Doctor:", "[doctor]").replace("Patient:", "[patient]")
+            norm.append(line)
+        stem = os.path.splitext(fn)[0]
+        primock_id = _normalize_primock_id(stem)
+        tdict[primock_id] = {"transcript": "\n".join(norm)}
+    return tdict
+
+def _load_annotations(path: str) -> List[dict]:
+    # Expect a JSON array (list of dicts). If JSONL, we also handle it gracefully.
+    if path.lower().endswith((".jsonl", ".ndjson")):
+        out = []
+        with open(path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if line:
+                    out.append(json.loads(line))
+        return out
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    if isinstance(data, list):
+        return data
+    raise ValueError(f"{path} must be a JSON list (or JSONL).")
+
+# ----------------------- HF builder -----------------------
+
+class SimordMergeConfig(datasets.BuilderConfig):
+    def __init__(self, **kwargs):
+        super().__init__(version=datasets.Version("1.0.0"), **kwargs)
+
+class SimordMerge(datasets.GeneratorBasedBuilder):
+    BUILDER_CONFIGS = [
+        SimordMergeConfig(
+            name="default",
+            description="SIMORD with transcripts merged via attach_transcript_section from mediqa-oe.",
+        )
+    ]
+    DEFAULT_CONFIG_NAME = "default"
+
+    def _info(self) -> datasets.DatasetInfo:
+        # We expose a compact schema:
+        # - id
+        # - transcript: sequence of {turn_id, speaker, transcript}
+        # - raw: JSON string dump of the full (possibly augmented) annotation record
+        features = datasets.Features(
+            {
+                "id": datasets.Value("string"),
+                "transcript": datasets.Sequence(
+                    {
+                        "turn_id": datasets.Value("int32"),
+                        "speaker": datasets.Value("string"),
+                        "transcript": datasets.Value("string"),
+                    }
+                ),
+                "raw": datasets.Value("string"),
+            }
+        )
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager: datasets.DownloadManager):
+        data_dir = self.config.data_dir or os.getcwd()
+
+        # Local annotations (lists of dicts with at least an "id")
+        train_path = os.path.join(data_dir, "train.json")
+        test1_path = os.path.join(data_dir, "test1.json")
+        test2_path = os.path.join(data_dir, "test2.json")
+
+        for p in (train_path, test1_path, test2_path):
+            if not os.path.isfile(p):
+                raise FileNotFoundError(f"Expected annotation file: {p}")
+
+        # Download & extract upstream sources (same URLs your script uses)
+        aci_dir = dl_manager.download_and_extract(ACI_BENCH_URL)
+        primock_dir = dl_manager.download_and_extract(PRIMOCK_URL)
+
+        # Build transcript_dict exactly like your script would
+        transcript_dict: Dict[str, dict] = {}
+        transcript_dict.update(_build_aci_transcript_dict(aci_dir))
+        transcript_dict.update(_build_primock_transcript_dict(primock_dir))
+
+        # Stash for use in _generate_examples
+        self._transcript_dict = transcript_dict
+
+        return [
+            datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"ann_path": train_path}),
+            datasets.SplitGenerator(name="test1", gen_kwargs={"ann_path": test1_path}),
+            datasets.SplitGenerator(name="test2", gen_kwargs={"ann_path": test2_path}),
+        ]
+
+    def _generate_examples(self, ann_path: str):
+        # Load the annotation list and call your function to attach transcripts
+        section = _load_annotations(ann_path)
+
+        # attach_transcript_section mutates in place, adding parsed turns to d["transcript"]
+        attach_transcript_section(section, self._transcript_dict)
+
+        for idx, rec in enumerate(section):
+            rid = str(rec.get("id", idx))
+            turns = rec.get("transcript") or []  # now a list of {turn_id, speaker, transcript}
+            # Store the full augmented record in "raw" for maximum fidelity
+            raw_str = json.dumps(rec, ensure_ascii=False)
+            yield idx, {
+                "id": rid,
+                "transcript": turns,
+                "raw": raw_str,
+            }