diff --git a/docs/api/datasets.rst b/docs/api/datasets.rst index 8d9a59d21..98fa7f741 100644 --- a/docs/api/datasets.rst +++ b/docs/api/datasets.rst @@ -238,6 +238,7 @@ Available Datasets datasets/pyhealth.datasets.BMDHSDataset datasets/pyhealth.datasets.COVID19CXRDataset datasets/pyhealth.datasets.ChestXray14Dataset + datasets/pyhealth.datasets.CheXpertPlusDataset datasets/pyhealth.datasets.PhysioNetDeIDDataset datasets/pyhealth.datasets.TUABDataset datasets/pyhealth.datasets.TUEVDataset diff --git a/docs/api/datasets/pyhealth.datasets.CheXpertPlusDataset.rst b/docs/api/datasets/pyhealth.datasets.CheXpertPlusDataset.rst new file mode 100644 index 000000000..61493c9fe --- /dev/null +++ b/docs/api/datasets/pyhealth.datasets.CheXpertPlusDataset.rst @@ -0,0 +1,12 @@ +pyhealth.datasets.CheXpertPlusDataset +==================================== + +CheXpert Plus dataset wrapper for report-driven chest X-ray knowledge graph +extraction. For more information see the dataset page +`here `_ +and paper `here `_. + +.. autoclass:: pyhealth.datasets.CheXpertPlusDataset + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/api/models.rst b/docs/api/models.rst index 7c3ac7c4b..ad503530e 100644 --- a/docs/api/models.rst +++ b/docs/api/models.rst @@ -177,6 +177,7 @@ API Reference models/pyhealth.models.GNN models/pyhealth.models.Transformer models/pyhealth.models.TransformersModel + models/pyhealth.models.ReXKGModel models/pyhealth.models.TransformerDeID models/pyhealth.models.RETAIN models/pyhealth.models.GAMENet diff --git a/docs/api/models/pyhealth.models.ReXKGModel.rst b/docs/api/models/pyhealth.models.ReXKGModel.rst new file mode 100644 index 000000000..7678750de --- /dev/null +++ b/docs/api/models/pyhealth.models.ReXKGModel.rst @@ -0,0 +1,10 @@ +pyhealth.models.ReXKGModel +=========================== + +ReXKG model for span-based radiology NER, pairwise relation extraction, +and downstream knowledge graph construction. + +.. autoclass:: pyhealth.models.ReXKGModel + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/api/tasks.rst b/docs/api/tasks.rst index 23a4e06e5..ae7d7adc8 100644 --- a/docs/api/tasks.rst +++ b/docs/api/tasks.rst @@ -226,6 +226,7 @@ Available Tasks ChestX-ray14 Binary Classification De-Identification NER ChestX-ray14 Multilabel Classification + Radiology KG Extraction Variant Classification (ClinVar) Mutation Pathogenicity (COSMIC) Cancer Survival Prediction (TCGA) diff --git a/docs/api/tasks/pyhealth.tasks.RadiologyKGExtractionTask.rst b/docs/api/tasks/pyhealth.tasks.RadiologyKGExtractionTask.rst new file mode 100644 index 000000000..4b1915fff --- /dev/null +++ b/docs/api/tasks/pyhealth.tasks.RadiologyKGExtractionTask.rst @@ -0,0 +1,9 @@ +pyhealth.tasks.RadiologyKGExtractionTask +======================================== + +Task for ReXKG-style entity and relation extraction from radiology reports. + +.. autoclass:: pyhealth.tasks.RadiologyKGExtractionTask + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/tutorials.rst b/docs/tutorials.rst index fcdab84ea..315f7ce84 100644 --- a/docs/tutorials.rst +++ b/docs/tutorials.rst @@ -218,6 +218,8 @@ These examples are located in ``examples/cxr/``. - VAE for chest X-ray image generation * - ``cxr/ChestXray-image-generation-GAN.ipynb`` - GAN for chest X-ray image generation (notebook) + * - ``cxr/chexpert_plus_rexkg.ipynb`` + - Radiology KG extraction with CheXpert Plus (ReXKG pipeline, notebook) Interpretability ---------------- diff --git a/examples/cxr/chexpert_plus_rexkg.ipynb b/examples/cxr/chexpert_plus_rexkg.ipynb new file mode 100644 index 000000000..14caf8a2b --- /dev/null +++ b/examples/cxr/chexpert_plus_rexkg.ipynb @@ -0,0 +1,2434 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5b957c77", + "metadata": {}, + "source": [ + "# Radiology Knowledge Graph Extraction with CheXpert Plus (ReXKG)\n", + "\n", + "Full **local** walkthrough of the ReXKG pipeline:\n", + "\n", + "1. Configure local paths and load PyHealth from the repo\n", + "2. Load the CheXpert Plus dataset (`CheXpertPlusDataset`)\n", + "3. Apply the KG extraction task (`RadiologyKGExtractionTask`)\n", + "4. **GPT-4o entity extraction** on a small subset (mirrors `gpt4_entity_extraction.py`)\n", + "5. **GPT-4o relation extraction** (mirrors `gpt4_relation_extraction.py`)\n", + "6. Initialize `ReXKGModel` (BERT span-NER + pairwise RE)\n", + "7. Build and inspect the Knowledge Graph\n", + "\n", + "**Papers:** ReXKG https://arxiv.org/abs/2408.14397 · CheXpert Plus https://arxiv.org/abs/2405.19111 \n", + "**Authors:** Aaron Miller · Kathryn Thompson · Pushpendra Tiwari" + ] + }, + { + "cell_type": "markdown", + "id": "15cb3c95", + "metadata": {}, + "source": [ + "## Step 0: Install dependencies\n", + "\n", + "Run once per environment. PyHealth is loaded from the repo — no pip install needed for it." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "aaabf43f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n", + "To disable this warning, you can either:\n", + "\t- Avoid using `tokenizers` before the fork if possible\n", + "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install --quiet transformers ipywidgets openai tqdm networkx matplotlib pandas torch\n" + ] + }, + { + "cell_type": "markdown", + "id": "0f359268", + "metadata": {}, + "source": [ + "## Step 1: Configure local paths\n", + "\n", + "The cell walks up from `os.getcwd()` until it finds a `pyhealth/` sub-directory,\n", + "so it works regardless of how the Jupyter kernel was launched." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "9e63bfbd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pyhealth loaded from : /Users/pushpendratiwari/Desktop/ReXKG-main/PyHealth/pyhealth/__init__.py\n", + "DATA_ROOT : /Users/pushpendratiwari/Desktop/ReXKG-main/src/data/chexpert_plus\n", + "CACHE_DIR : /Users/pushpendratiwari/Desktop/ReXKG-main/PyHealth/examples/cxr/rexkg_cache\n" + ] + } + ], + "source": [ + "import sys, os\n", + "\n", + "# Walk up from cwd to find the PyHealth repo root (the dir that contains pyhealth/)\n", + "_search = os.path.abspath(os.getcwd())\n", + "PYHEALTH_DIR = None\n", + "for _ in range(6):\n", + " if os.path.isdir(os.path.join(_search, 'pyhealth')):\n", + " PYHEALTH_DIR = _search\n", + " break\n", + " _search = os.path.dirname(_search)\n", + "if PYHEALTH_DIR is None:\n", + " raise RuntimeError(\n", + " f\"Could not find a 'pyhealth/' package starting from {os.getcwd()}.\\n\"\n", + " \"Launch the kernel from inside the PyHealth repo (e.g. cd PyHealth && jupyter notebook).\"\n", + " )\n", + "\n", + "DATA_ROOT = os.path.abspath(os.path.join(PYHEALTH_DIR, '..', 'src', 'data', 'chexpert_plus'))\n", + "CACHE_DIR = os.path.join(PYHEALTH_DIR, 'examples', 'cxr', 'rexkg_cache')\n", + "os.makedirs(CACHE_DIR, exist_ok=True)\n", + "\n", + "if PYHEALTH_DIR not in sys.path:\n", + " sys.path.insert(0, PYHEALTH_DIR)\n", + "\n", + "import importlib, pyhealth\n", + "importlib.reload(pyhealth)\n", + "print('pyhealth loaded from :', pyhealth.__file__)\n", + "print('DATA_ROOT :', DATA_ROOT)\n", + "print('CACHE_DIR :', CACHE_DIR)\n", + "assert os.path.isdir(DATA_ROOT), (\n", + " f'DATA_ROOT not found: {DATA_ROOT}\\n'\n", + " 'Place df_chexpert_plus_240401.csv inside that folder.'\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "3a65193e", + "metadata": {}, + "source": [ + "## Step 2: Load the CheXpert Plus Dataset\n", + "\n", + "`path_to_image` is used as the patient identifier; `section_findings` is the\n", + "radiology report text. `dev=True` caps at 1 000 studies for exploration." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "c2fd0a12", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initializing CheXpertPlus dataset from /Users/pushpendratiwari/Desktop/ReXKG-main/src/data/chexpert_plus (dev mode: True)\n", + "Initializing CheXpertPlus dataset from /Users/pushpendratiwari/Desktop/ReXKG-main/src/data/chexpert_plus (dev mode: True)\n", + "Initializing CheXpertPlus dataset from /Users/pushpendratiwari/Desktop/ReXKG-main/src/data/chexpert_plus (dev mode: True)\n", + "No cache_dir provided. Using default cache dir: /Users/pushpendratiwari/Library/Caches/pyhealth/8a94d02f-95ae-52b8-85f1-794bb970fa9e\n", + "No cache_dir provided. Using default cache dir: /Users/pushpendratiwari/Library/Caches/pyhealth/8a94d02f-95ae-52b8-85f1-794bb970fa9e\n", + "No cache_dir provided. Using default cache dir: /Users/pushpendratiwari/Library/Caches/pyhealth/8a94d02f-95ae-52b8-85f1-794bb970fa9e\n", + "Found cached event dataframe: /Users/pushpendratiwari/Library/Caches/pyhealth/8a94d02f-95ae-52b8-85f1-794bb970fa9e/global_event_df.parquet\n", + "Found cached event dataframe: /Users/pushpendratiwari/Library/Caches/pyhealth/8a94d02f-95ae-52b8-85f1-794bb970fa9e/global_event_df.parquet\n", + "Found cached event dataframe: /Users/pushpendratiwari/Library/Caches/pyhealth/8a94d02f-95ae-52b8-85f1-794bb970fa9e/global_event_df.parquet\n", + "Dataset: CheXpertPlus\n", + "Dev mode: True\n", + "Number of patients: 1000\n", + "Number of events: 1000\n" + ] + } + ], + "source": [ + "from pyhealth.datasets import CheXpertPlusDataset\n", + "\n", + "dataset = CheXpertPlusDataset(\n", + " root=DATA_ROOT,\n", + " dev=True,\n", + ")\n", + "dataset.stats()\n" + ] + }, + { + "cell_type": "markdown", + "id": "fec4f32c", + "metadata": {}, + "source": [ + "## Step 3: Apply the Radiology KG Extraction Task\n", + "\n", + "`RadiologyKGExtractionTask` converts each report into a sample: \n", + "`{text, entities: [], relations: []}` — entity/relation lists are populated at inference." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "d1711132", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setting task RadiologyKGExtraction for CheXpertPlus base dataset...\n", + "Setting task RadiologyKGExtraction for CheXpertPlus base dataset...\n", + "Setting task RadiologyKGExtraction for CheXpertPlus base dataset...\n", + "Task cache paths: task_df=/Users/pushpendratiwari/Library/Caches/pyhealth/8a94d02f-95ae-52b8-85f1-794bb970fa9e/tasks/RadiologyKGExtraction_d9050265-565a-51f3-9525-2d1f6d6a216a/task_df.ld, samples=/Users/pushpendratiwari/Library/Caches/pyhealth/8a94d02f-95ae-52b8-85f1-794bb970fa9e/tasks/RadiologyKGExtraction_d9050265-565a-51f3-9525-2d1f6d6a216a/samples_cdbbc602-34e2-5a41-8643-4c76b08829f6.ld\n", + "Task cache paths: task_df=/Users/pushpendratiwari/Library/Caches/pyhealth/8a94d02f-95ae-52b8-85f1-794bb970fa9e/tasks/RadiologyKGExtraction_d9050265-565a-51f3-9525-2d1f6d6a216a/task_df.ld, samples=/Users/pushpendratiwari/Library/Caches/pyhealth/8a94d02f-95ae-52b8-85f1-794bb970fa9e/tasks/RadiologyKGExtraction_d9050265-565a-51f3-9525-2d1f6d6a216a/samples_cdbbc602-34e2-5a41-8643-4c76b08829f6.ld\n", + "Task cache paths: task_df=/Users/pushpendratiwari/Library/Caches/pyhealth/8a94d02f-95ae-52b8-85f1-794bb970fa9e/tasks/RadiologyKGExtraction_d9050265-565a-51f3-9525-2d1f6d6a216a/task_df.ld, samples=/Users/pushpendratiwari/Library/Caches/pyhealth/8a94d02f-95ae-52b8-85f1-794bb970fa9e/tasks/RadiologyKGExtraction_d9050265-565a-51f3-9525-2d1f6d6a216a/samples_cdbbc602-34e2-5a41-8643-4c76b08829f6.ld\n", + "Found cached processed samples at /Users/pushpendratiwari/Library/Caches/pyhealth/8a94d02f-95ae-52b8-85f1-794bb970fa9e/tasks/RadiologyKGExtraction_d9050265-565a-51f3-9525-2d1f6d6a216a/samples_cdbbc602-34e2-5a41-8643-4c76b08829f6.ld, skipping processing.\n", + "Found cached processed samples at /Users/pushpendratiwari/Library/Caches/pyhealth/8a94d02f-95ae-52b8-85f1-794bb970fa9e/tasks/RadiologyKGExtraction_d9050265-565a-51f3-9525-2d1f6d6a216a/samples_cdbbc602-34e2-5a41-8643-4c76b08829f6.ld, skipping processing.\n", + "Found cached processed samples at /Users/pushpendratiwari/Library/Caches/pyhealth/8a94d02f-95ae-52b8-85f1-794bb970fa9e/tasks/RadiologyKGExtraction_d9050265-565a-51f3-9525-2d1f6d6a216a/samples_cdbbc602-34e2-5a41-8643-4c76b08829f6.ld, skipping processing.\n", + "Total samples: 218\n" + ] + } + ], + "source": [ + "from pyhealth.tasks import RadiologyKGExtractionTask\n", + "\n", + "task = RadiologyKGExtractionTask(\n", + " findings_only=True,\n", + " min_text_length=10,\n", + ")\n", + "samples = dataset.set_task(task)\n", + "print(f'Total samples: {len(samples)}')\n" + ] + }, + { + "cell_type": "markdown", + "id": "9848f01c", + "metadata": {}, + "source": [ + "## Step 4: GPT-4o Entity Extraction (small subset)\n", + "\n", + "Mirrors `gpt4_entity_extraction.py`. \n", + "Entity types: `anatomy`, `disorder_present`, `disorder_notpresent`, `procedures`,\n", + "`devices_present`, `devices_notpresent`, `size`, `concept`.\n", + "\n", + "> **Cost:** ~\\$0.01–0.03 per report with `gpt-4o`. Keep `N_SAMPLES` small (5–20) for exploration.\n", + "\n", + "> **Security:** Set `OPENAI_API_KEY` as an environment variable — never paste the key directly in this cell." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "2c162ca5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Entity cache : /Users/pushpendratiwari/Desktop/ReXKG-main/PyHealth/examples/cxr/rexkg_cache/gpt4_entities_subset.json\n", + "Relation cache: /Users/pushpendratiwari/Desktop/ReXKG-main/PyHealth/examples/cxr/rexkg_cache/gpt4_relations_subset.json\n" + ] + } + ], + "source": [ + "import os\n", + "\n", + "# Set via shell: export OPENAI_API_KEY='sk-...'\n", + "OPENAI_API_KEY = os.getenv('OPENAI_API_KEY', '')\n", + "OPENAI_API_BASE = os.getenv('OPENAI_API_BASE', 'https://api.openai.com/v1')\n", + "\n", + "N_SAMPLES = 5 # reports to send to GPT\n", + "\n", + "GPT_ENTITY_CACHE = os.path.join(CACHE_DIR, 'gpt4_entities_subset.json')\n", + "GPT_RELATION_CACHE = os.path.join(CACHE_DIR, 'gpt4_relations_subset.json')\n", + "print('Entity cache :', GPT_ENTITY_CACHE)\n", + "print('Relation cache:', GPT_RELATION_CACHE)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "5d661f8f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GPT entity-extraction helpers ready.\n" + ] + } + ], + "source": [ + "import json, time\n", + "import openai\n", + "from tqdm import tqdm\n", + "\n", + "client = openai.OpenAI(api_key=OPENAI_API_KEY, base_url=OPENAI_API_BASE)\n", + "\n", + "# ── Few-shot prompt (from gpt4_entity_extraction.py) ────────────────────── #\n", + "_NER_FEWSHOT = [\n", + " {\n", + " 'context': (\n", + " ' Unchanged position of the left upper extremity PICC line. '\n", + " 'Again seen are surgical clips projecting over the right hemithorax. '\n", + " 'Increased stranding opacities are noted in the left retrocardiac region.<\\\\Input>'\n", + " ),\n", + " 'response': (\n", + " \"{'Unchanged position of the left upper extremity PICC line.':\"\n", + " \"{'Unchanged':'concept','position':'concept','left':'concept','upper':'concept',\"\n", + " \"'extremity':'anatomy','PICC line':'device_present'},\"\n", + " \"'Again seen are surgical clips projecting over the right hemithorax.':\"\n", + " \"{'surgical clips':'device_present','right':'concept','hemithorax':'anatomy'},\"\n", + " \"'Increased stranding opacities are noted in the left retrocardiac region.':\"\n", + " \"{'Increased':'concept','stranding':'concept','opacities':'disorder_present',\"\n", + " \"'left':'concept','retrocardiac':'anatomy','region':'anatomy'}}\"\n", + " ),\n", + " }\n", + "]\n", + "\n", + "_NER_SYSTEM = (\n", + " 'You are a radiologist performing clinical term extraction from the FINDINGS and '\n", + " 'IMPRESSION sections in the radiology report. '\n", + " \"A clinical term can be in ['anatomy','disorder_present','disorder_notpresent',\"\n", + " \"'procedures','devices','concept','devices_present','devices_notpresent','size']. \"\n", + " \"'anatomy'=body part; 'disorder_present'=present finding; 'disorder_notpresent'=absent finding; \"\n", + " \"'procedures'=diagnostic/therapeutic procedure; 'devices'=medical apparatus; \"\n", + " \"'size'=measurement e.g. 3mm; 'concept'=descriptor/modifier. \"\n", + " 'Extract one word at a time. Words like \"no\" are NOT entities. '\n", + " 'Input: <\\\\Input>. '\n", + " \"Reply JSON: {'':{'entity':'entity_type',...},...}\"\n", + ")\n", + "\n", + "\n", + "def _ner_messages(text):\n", + " msgs = [{'role': 'system', 'content': _NER_SYSTEM}]\n", + " for s in _NER_FEWSHOT:\n", + " msgs.append({'role': 'user', 'content': s['context']})\n", + " msgs.append({'role': 'assistant', 'content': s['response']})\n", + " msgs.append({'role': 'user', 'content': f' {text} <\\\\Input>'})\n", + " return msgs\n", + "\n", + "\n", + "def _estimate_cost(prompt_tokens, completion_tokens):\n", + " return prompt_tokens * 0.005 / 1000 + completion_tokens * 0.015 / 1000\n", + "\n", + "\n", + "def gpt_extract_entities(text):\n", + " resp = client.chat.completions.create(\n", + " model='gpt-4o-2024-05-13',\n", + " messages=_ner_messages(text),\n", + " response_format={'type': 'json_object'},\n", + " )\n", + " raw = resp.choices[0].message.content\n", + " cost = _estimate_cost(resp.usage.prompt_tokens, resp.usage.completion_tokens)\n", + " try:\n", + " return json.loads(raw), cost\n", + " except Exception:\n", + " return raw, cost\n", + "\n", + "\n", + "print('GPT entity-extraction helpers ready.')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "0601c4b2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded 5 cached entity results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPT entity extraction: 100%|████████████████████| 5/5 [00:00<00:00, 5235.03it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Done. Cumulative cost: $0.0000\n", + "Saved to /Users/pushpendratiwari/Desktop/ReXKG-main/PyHealth/examples/cxr/rexkg_cache/gpt4_entities_subset.json\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "csv_path = os.path.join(DATA_ROOT, 'df_chexpert_plus_240401.csv')\n", + "df_gpt = pd.read_csv(csv_path).dropna(subset=['section_findings']).head(N_SAMPLES)\n", + "\n", + "try:\n", + " with open(GPT_ENTITY_CACHE) as fh:\n", + " entity_cache = json.load(fh)\n", + " print(f'Loaded {len(entity_cache)} cached entity results.')\n", + "except FileNotFoundError:\n", + " entity_cache = {}\n", + "\n", + "total_cost = 0.0\n", + "for _, row in tqdm(df_gpt.iterrows(), total=len(df_gpt), desc='GPT entity extraction'):\n", + " pid, text = row['path_to_image'], row['section_findings']\n", + " if pid in entity_cache:\n", + " continue\n", + " try:\n", + " res, cost = gpt_extract_entities(text)\n", + " total_cost += cost\n", + " entity_cache[pid] = {'section_findings': text, 'res': res, 'cost': cost}\n", + " except Exception as exc:\n", + " print(f' Error on {pid}: {exc}')\n", + " time.sleep(1)\n", + " with open(GPT_ENTITY_CACHE, 'w') as fh:\n", + " json.dump(entity_cache, fh, indent=2)\n", + "\n", + "print(f'\\nDone. Cumulative cost: ${total_cost:.4f}')\n", + "print(f'Saved to {GPT_ENTITY_CACHE}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "efcb3416", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Patient/Study: train/patient04528/study1/view2_lateral.jpg\n", + "Findings snippet: \n", + " \n", + "Unchanged position of the left upper extremity PICC line. Again seen \n", + "are surgical clips projecting over the right hemithorax. The \n", + "cardiomediastinal silhouette is stable in appearance. Increased \n", + "\n", + "\n", + "Extracted entities (per sentence):\n", + " [Unchanged position of the left upper extremity PICC line....]\n", + " 'Unchanged' -> concept\n", + " 'position' -> concept\n", + " 'left' -> concept\n", + " 'upper' -> concept\n", + " 'extremity' -> anatomy\n", + " 'PICC line' -> devices_present\n", + " [Again seen are surgical clips projecting over the right hemi...]\n", + " 'surgical clips' -> devices_present\n", + " 'right' -> concept\n", + " 'hemithorax' -> anatomy\n", + " [The cardiomediastinal silhouette is stable in appearance....]\n", + " 'cardiomediastinal' -> anatomy\n", + " 'silhouette' -> anatomy\n", + " 'stable' -> concept\n", + " 'appearance' -> concept\n", + " [Increased stranding opacities are noted in the left retrocar...]\n", + " 'Increased' -> concept\n", + " 'stranding' -> concept\n", + " 'opacities' -> disorder_present\n", + " 'left' -> concept\n", + " 'retrocardiac' -> anatomy\n", + " 'region' -> anatomy\n", + " [Subtle stranding opacities in the right upper lung zone are ...]\n", + " 'Subtle' -> concept\n", + " 'stranding' -> concept\n", + " 'opacities' -> disorder_present\n", + " 'right' -> concept\n", + " 'upper' -> concept\n", + " 'lung' -> anatomy\n", + " 'zone' -> anatomy\n", + " 'unchanged' -> concept\n", + " [There are no pleural or significant bony abnormalities....]\n", + " 'pleural' -> anatomy\n", + " 'significant' -> concept\n", + " 'bony' -> anatomy\n", + " 'abnormalities' -> disorder_notpresent\n", + " [Absence of the right breast shadow compatible with prior mas...]\n", + " 'right' -> concept\n", + " 'breast' -> anatomy\n", + " 'shadow' -> anatomy\n", + " 'prior' -> concept\n", + " 'mastectomy' -> procedures\n" + ] + } + ], + "source": [ + "# Inspect entity results for the first study\n", + "first_key = next(iter(entity_cache))\n", + "print('Patient/Study:', first_key)\n", + "print('Findings snippet:', entity_cache[first_key]['section_findings'][:200])\n", + "print('\\nExtracted entities (per sentence):')\n", + "for sent, ents in entity_cache[first_key]['res'].items():\n", + " print(f' [{sent[:60]}...]')\n", + " for term, etype in ents.items():\n", + " print(f' {term!r:30s} -> {etype}')\n" + ] + }, + { + "cell_type": "markdown", + "id": "c31a5e70", + "metadata": {}, + "source": [ + "## Step 5: GPT-4o Relation Extraction\n", + "\n", + "Mirrors `gpt4_relation_extraction.py`. \n", + "Relation types: `modify`, `located_at`, `suggestive_of`." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "e8100920", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GPT relation-extraction helpers ready.\n" + ] + } + ], + "source": [ + "# ── Few-shot prompt (from gpt4_relation_extraction.py) ──────────────────── #\n", + "_RE_FEWSHOT = [\n", + " {\n", + " 'context': (\n", + " \"{'Bones are stable with mild degenerative changes of the spine.':\"\n", + " \"{'Bones':'anatomy','stable':'concept','mild':'concept',\"\n", + " \"'degenerative changes':'disorder_present','spine':'anatomy'}}\"\n", + " ),\n", + " 'response': (\n", + " \"{'Bones are stable with mild degenerative changes of the spine.':\"\n", + " \"[{'stable':'Bones','relation':'modify'},\"\n", + " \"{'mild':'degenerative changes','relation':'modify'},\"\n", + " \"{'degenerative changes':'spine','relation':'located_at'}]}\"\n", + " ),\n", + " },\n", + " {\n", + " 'context': (\n", + " \"{'A dense retrocardiac opacity remains present with slight blunting of \"\n", + " \"the left costophrenic angle, suggestive of a small effusion.':\"\n", + " \"{'dense':'concept','retrocardiac':'anatomy','opacity':'disorder_present',\"\n", + " \"'slight':'concept','blunting':'disorder_present','left':'concept',\"\n", + " \"'costophrenic':'anatomy','angle':'anatomy','small':'concept','effusion':'disorder_present'}}\"\n", + " ),\n", + " 'response': (\n", + " \"{'A dense retrocardiac opacity remains present with slight blunting of \"\n", + " \"the left costophrenic angle, suggestive of a small effusion.':\"\n", + " \"[{'dense':'opacity','relation':'modify'},{'opacity':'retrocardiac','relation':'located_at'},\"\n", + " \"{'slight':'blunting','relation':'modify'},{'blunting':'angle','relation':'modify'},\"\n", + " \"{'left':'costophrenic','relation':'modify'},{'small':'effusion','relation':'modify'},\"\n", + " \"{'effusion':'costophrenic','relation':'located_at'},\"\n", + " \"{'opacity':'effusion','relation':'suggestive_of'},\"\n", + " \"{'blunting':'effusion','relation':'suggestive_of'}]}\"\n", + " ),\n", + " },\n", + "]\n", + "\n", + "_RE_SYSTEM = (\n", + " 'You are a radiologist performing relation extraction from radiology reports. '\n", + " \"Relations: 'modify' (source modifies target), 'located_at' (source located at anatomy), \"\n", + " \"'suggestive_of' (source finding suggests target disease). \"\n", + " \"concept->anatomy links always use 'modify'. \"\n", + " \"Input JSON: {'sentence':{'entity':'type',...},...}. \"\n", + " \"Reply JSON: {'sentence':[{'src':'tgt','relation':'rel'},...]}.\"\n", + ")\n", + "\n", + "\n", + "def _re_messages(entity_json):\n", + " msgs = [{'role': 'system', 'content': _RE_SYSTEM}]\n", + " for s in _RE_FEWSHOT:\n", + " msgs.append({'role': 'user', 'content': s['context']})\n", + " msgs.append({'role': 'assistant', 'content': s['response']})\n", + " msgs.append({'role': 'user', 'content': entity_json})\n", + " return msgs\n", + "\n", + "\n", + "def gpt_extract_relations(entity_dict):\n", + " resp = client.chat.completions.create(\n", + " model='gpt-4o-2024-05-13',\n", + " messages=_re_messages(json.dumps(entity_dict)),\n", + " response_format={'type': 'json_object'},\n", + " )\n", + " raw = resp.choices[0].message.content\n", + " cost = _estimate_cost(resp.usage.prompt_tokens, resp.usage.completion_tokens)\n", + " try:\n", + " return json.loads(raw), cost\n", + " except Exception:\n", + " return raw, cost\n", + "\n", + "\n", + "print('GPT relation-extraction helpers ready.')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "1bdada4a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded 5 cached relation results.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "GPT relation extraction: 100%|████████████████| 5/5 [00:00<00:00, 218453.33it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Done. Cumulative relation cost: $0.0000\n", + "Saved to /Users/pushpendratiwari/Desktop/ReXKG-main/PyHealth/examples/cxr/rexkg_cache/gpt4_relations_subset.json\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "try:\n", + " with open(GPT_RELATION_CACHE) as fh:\n", + " relation_cache = json.load(fh)\n", + " print(f'Loaded {len(relation_cache)} cached relation results.')\n", + "except FileNotFoundError:\n", + " relation_cache = {}\n", + "\n", + "total_re_cost = 0.0\n", + "for pid, entry in tqdm(entity_cache.items(), desc='GPT relation extraction'):\n", + " if pid in relation_cache:\n", + " continue\n", + " entity_dict = entry.get('res', {})\n", + " if not entity_dict:\n", + " continue\n", + " try:\n", + " res, cost = gpt_extract_relations(entity_dict)\n", + " total_re_cost += cost\n", + " relation_cache[pid] = {**entry, 'res_relation': res, 'cost_relation': cost}\n", + " except Exception as exc:\n", + " print(f' Error on {pid}: {exc}')\n", + " time.sleep(1)\n", + " with open(GPT_RELATION_CACHE, 'w') as fh:\n", + " json.dump(relation_cache, fh, indent=2)\n", + "\n", + "print(f'\\nDone. Cumulative relation cost: ${total_re_cost:.4f}')\n", + "print(f'Saved to {GPT_RELATION_CACHE}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "bff9170f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Patient/Study: train/patient04528/study1/view2_lateral.jpg\n", + "\n", + "Extracted relations (per sentence):\n", + " [Unchanged position of the left upper extremity PICC line....]\n", + " 'Unchanged' --[modify]--> 'position'\n", + " 'position' --[modify]--> 'extremity'\n", + " 'left' --[modify]--> 'extremity'\n", + " 'upper' --[modify]--> 'extremity'\n", + " 'PICC line' --[located_at]--> 'extremity'\n", + " [Again seen are surgical clips projecting over the right hemi...]\n", + " 'surgical clips' --[located_at]--> 'hemithorax'\n", + " 'right' --[modify]--> 'hemithorax'\n", + " [The cardiomediastinal silhouette is stable in appearance....]\n", + " 'stable' --[modify]--> 'silhouette'\n", + " 'cardiomediastinal' --[modify]--> 'silhouette'\n", + " [Increased stranding opacities are noted in the left retrocar...]\n", + " 'Increased' --[modify]--> 'opacities'\n", + " 'stranding' --[modify]--> 'opacities'\n", + " 'opacities' --[located_at]--> 'region'\n", + " 'left' --[modify]--> 'region'\n", + " 'retrocardiac' --[modify]--> 'region'\n", + " [Subtle stranding opacities in the right upper lung zone are ...]\n", + " 'Subtle' --[modify]--> 'opacities'\n", + " 'stranding' --[modify]--> 'opacities'\n", + " 'opacities' --[located_at]--> 'zone'\n", + " 'right' --[modify]--> 'zone'\n", + " 'upper' --[modify]--> 'zone'\n", + " 'lung' --[modify]--> 'zone'\n", + " 'unchanged' --[modify]--> 'opacities'\n", + " [There are no pleural or significant bony abnormalities....]\n", + " 'abnormalities' --[located_at]--> 'pleural'\n", + " 'abnormalities' --[located_at]--> 'bony'\n", + " 'significant' --[modify]--> 'abnormalities'\n", + " [Absence of the right breast shadow compatible with prior mas...]\n", + " 'mastectomy' --[modify]--> 'shadow'\n", + " 'prior' --[modify]--> 'mastectomy'\n", + " 'shadow' --[located_at]--> 'breast'\n", + " 'right' --[modify]--> 'breast'\n" + ] + } + ], + "source": [ + "# Inspect relation results for the first study\n", + "first_key = next(iter(relation_cache))\n", + "print('Patient/Study:', first_key)\n", + "print('\\nExtracted relations (per sentence):')\n", + "for sent, rels in relation_cache[first_key].get('res_relation', {}).items():\n", + " print(f' [{sent[:60]}...]')\n", + " if isinstance(rels, list):\n", + " for r in rels:\n", + " rel_type = r.get('relation', '?')\n", + " entities = [(k, v) for k, v in r.items() if k != 'relation']\n", + " if entities:\n", + " src, tgt = entities[0]\n", + " print(f\" '{src}' --[{rel_type}]--> '{tgt}'\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "04d84eb3", + "metadata": {}, + "source": [ + "## Step 6: Initialize the ReXKG Model (BERT-based)\n", + "\n", + "`ReXKGModel` attaches a **span NER head** and a **pairwise relation head** on top of a BERT encoder. \n", + "Use for large-scale inference after fine-tuning, or combine with the GPT outputs above." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "629e9454", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ReXKGModel(\n", + " (encoder): BertModel(\n", + " (embeddings): BertEmbeddings(\n", + " (word_embeddings): Embedding(30522, 768, padding_idx=0)\n", + " (position_embeddings): Embedding(512, 768)\n", + " (token_type_embeddings): Embedding(2, 768)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (encoder): BertEncoder(\n", + " (layer): ModuleList(\n", + " (0-11): 12 x BertLayer(\n", + " (attention): BertAttention(\n", + " (self): BertSdpaSelfAttention(\n", + " (query): Linear(in_features=768, out_features=768, bias=True)\n", + " (key): Linear(in_features=768, out_features=768, bias=True)\n", + " (value): Linear(in_features=768, out_features=768, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (output): BertSelfOutput(\n", + " (dense): Linear(in_features=768, out_features=768, bias=True)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): BertIntermediate(\n", + " (dense): Linear(in_features=768, out_features=3072, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): BertOutput(\n", + " (dense): Linear(in_features=3072, out_features=768, bias=True)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (pooler): BertPooler(\n", + " (dense): Linear(in_features=768, out_features=768, bias=True)\n", + " (activation): Tanh()\n", + " )\n", + " )\n", + " (ner_head): _SpanNERHead(\n", + " (hidden_dropout): Dropout(p=0.1, inplace=False)\n", + " (width_embedding): Embedding(9, 150)\n", + " (network): Sequential(\n", + " (0): Linear(in_features=1686, out_features=150, bias=True)\n", + " (1): ReLU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=150, out_features=150, bias=True)\n", + " )\n", + " (output): Linear(in_features=150, out_features=9, bias=True)\n", + " )\n", + " (rel_head): _PairwiseRelationHead(\n", + " (layer_norm): LayerNorm((1536,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " (classifier): Linear(in_features=1536, out_features=4, bias=True)\n", + " )\n", + ")\n" + ] + } + ], + "source": [ + "from pyhealth.models import ReXKGModel\n", + "\n", + "model = ReXKGModel(\n", + " dataset=samples,\n", + " bert_model_name='bert-base-uncased',\n", + " max_span_length=8, # smaller -> fewer candidate spans -> faster pairwise RE\n", + ")\n", + "print(model)" + ] + }, + { + "cell_type": "markdown", + "id": "75f1da9d", + "metadata": {}, + "source": [ + "### (Optional) Load a pretrained ReXKG checkpoint\n", + "\n", + "If you have a checkpoint fine-tuned on ReXKG / MIMIC NER, load it here. \n", + "The **GPT-extracted** entities/relations from Steps 4–5 can also be used directly to build a KG without fine-tuning." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "bfbc6ea9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded checkpoint: /Users/pushpendratiwari/Desktop/ReXKG-main/src/ner/result/run_entity/model.safetensors\n", + " BERT encoder keys : 199\n", + " NER head keys : 7\n", + " Missing (RE head) : 5\n" + ] + } + ], + "source": [ + "# Load pretrained NER weights from src/ner/result/run_entity/\n", + "# Key mapping:\n", + "# bert.* -> encoder.*\n", + "# width_embedding.* -> ner_head.width_embedding.*\n", + "# ner_classifier.0.network.* -> ner_head.network.*\n", + "# ner_classifier.1.* -> ner_head.output.*\n", + "from safetensors.torch import load_file as load_safetensors\n", + "import os\n", + "\n", + "ENTITY_CKPT = os.path.abspath(\n", + " os.path.join(PYHEALTH_DIR, '..', 'src', 'ner', 'result', 'run_entity', 'model.safetensors')\n", + ")\n", + "\n", + "if os.path.exists(ENTITY_CKPT):\n", + " ckpt = load_safetensors(ENTITY_CKPT)\n", + "\n", + " remapped = {}\n", + " for k, v in ckpt.items():\n", + " if k.startswith('bert.'):\n", + " remapped['encoder.' + k[5:]] = v\n", + " elif k.startswith('width_embedding.'):\n", + " remapped['ner_head.' + k] = v\n", + " elif k.startswith('ner_classifier.0.network.'):\n", + " suffix = k[len('ner_classifier.0.network.'):]\n", + " remapped[f'ner_head.network.{suffix}'] = v\n", + " elif k.startswith('ner_classifier.1.'):\n", + " suffix = k[len('ner_classifier.1.'):]\n", + " remapped[f'ner_head.output.{suffix}'] = v\n", + "\n", + " missing, unexpected = model.load_state_dict(remapped, strict=False)\n", + " ner_keys = [k for k in remapped if 'encoder' not in k]\n", + " print(f'Loaded checkpoint: {ENTITY_CKPT}')\n", + " print(f' BERT encoder keys : {len(remapped) - len(ner_keys)}')\n", + " print(f' NER head keys : {len(ner_keys)}')\n", + " print(f' Missing (RE head) : {len(missing)}')\n", + " if unexpected:\n", + " print(f' Unexpected keys : {unexpected}')\n", + "else:\n", + " print(f'Checkpoint not found at {ENTITY_CKPT} — using random weights.')\n" + ] + }, + { + "cell_type": "markdown", + "id": "84e07f77", + "metadata": {}, + "source": [ + "## Step 6b: BERT-based Entity & Relation Extraction\n", + "\n", + "Runs on the same small subset sent to GPT — useful for direct comparison." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "6a94aaab", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "train/patient04528/study1/view2_lateral.jpg: 59 entities\n", + " [concept] 'Unchanged'\n", + " [concept] 'position'\n", + " [concept] 'left'\n", + " [concept] 'upper'\n", + " [anatomy] 'ex'\n", + " [anatomy] 'tre'\n", + " [anatomy] 'mity'\n", + " [disorder_present] 'PIC'\n", + " [anatomy] 'C'\n", + " [disorder_present] 'line'\n", + " [concept] 'surgical'\n", + " [disorder_present] 'clips'\n", + " [concept] 'projecting'\n", + " [anatomy] 'hem'\n", + " [anatomy] 'ith'\n", + " [disorder_present] 'ora'\n", + " [disorder_present] 'x'\n", + " [anatomy] 'card'\n", + " [anatomy] 'iom'\n", + " [anatomy] 'ed'\n", + " [anatomy] 'ias'\n", + " [disorder_present] 'tina'\n", + " [anatomy] 'l'\n", + " [concept] 'silhouette'\n", + " [concept] 'stable'\n", + " [concept] 'appearance'\n", + " [concept] 'Increased'\n", + " [anatomy] 'strand'\n", + " [concept] 'ing'\n", + " [disorder_present] 'op'\n", + " [anatomy] 'ac'\n", + " [disorder_present] 'ities'\n", + " [concept] 'left'\n", + " [anatomy] 'retro'\n", + " [anatomy] 'card'\n", + " [anatomy] 'iac'\n", + " [anatomy] 'region'\n", + " [concept] 'Subtle'\n", + " [anatomy] 'strand'\n", + " [concept] 'ing'\n", + " [disorder_present] 'op'\n", + " [anatomy] 'ac'\n", + " [concept] 'upper'\n", + " [anatomy] 'lung'\n", + " [anatomy] 'zone'\n", + " [concept] 'unchanged'\n", + " [anatomy] 'pl'\n", + " [anatomy] 'eur'\n", + " [anatomy] 'al'\n", + " [concept] 'significant'\n", + " [anatomy] 'bony'\n", + " [disorder_present] 'abnormalities'\n", + " [concept] 'Absence'\n", + " [anatomy] 'breast'\n", + " [anatomy] 'shadow'\n", + " [concept] 'prior'\n", + " [anatomy] 'mast'\n", + " [anatomy] 'ect'\n", + " [disorder_present] 'omy'\n", + "\n", + "train/patient04528/study1/view1_frontal.jpg: 59 entities\n", + " [concept] 'Unchanged'\n", + " [concept] 'position'\n", + " [concept] 'left'\n", + " [concept] 'upper'\n", + " [anatomy] 'ex'\n", + " [anatomy] 'tre'\n", + " [anatomy] 'mity'\n", + " [disorder_present] 'PIC'\n", + " [anatomy] 'C'\n", + " [disorder_present] 'line'\n", + " [concept] 'surgical'\n", + " [disorder_present] 'clips'\n", + " [concept] 'projecting'\n", + " [anatomy] 'hem'\n", + " [anatomy] 'ith'\n", + " [disorder_present] 'ora'\n", + " [disorder_present] 'x'\n", + " [anatomy] 'card'\n", + " [anatomy] 'iom'\n", + " [anatomy] 'ed'\n", + " [anatomy] 'ias'\n", + " [disorder_present] 'tina'\n", + " [anatomy] 'l'\n", + " [concept] 'silhouette'\n", + " [concept] 'stable'\n", + " [concept] 'appearance'\n", + " [concept] 'Increased'\n", + " [anatomy] 'strand'\n", + " [concept] 'ing'\n", + " [disorder_present] 'op'\n", + " [anatomy] 'ac'\n", + " [disorder_present] 'ities'\n", + " [concept] 'left'\n", + " [anatomy] 'retro'\n", + " [anatomy] 'card'\n", + " [anatomy] 'iac'\n", + " [anatomy] 'region'\n", + " [concept] 'Subtle'\n", + " [anatomy] 'strand'\n", + " [concept] 'ing'\n", + " [disorder_present] 'op'\n", + " [anatomy] 'ac'\n", + " [concept] 'upper'\n", + " [anatomy] 'lung'\n", + " [anatomy] 'zone'\n", + " [concept] 'unchanged'\n", + " [anatomy] 'pl'\n", + " [anatomy] 'eur'\n", + " [anatomy] 'al'\n", + " [concept] 'significant'\n", + " [anatomy] 'bony'\n", + " [disorder_present] 'abnormalities'\n", + " [concept] 'Absence'\n", + " [anatomy] 'breast'\n", + " [anatomy] 'shadow'\n", + " [concept] 'prior'\n", + " [anatomy] 'mast'\n", + " [anatomy] 'ect'\n", + " [disorder_present] 'omy'\n", + "\n", + "train/patient11162/study3/view1_frontal.jpg: 55 entities\n", + " [concept] 'red'\n", + " [anatomy] 'emon'\n", + " [anatomy] 'stra'\n", + " [concept] 'right'\n", + " [concept] 'internal'\n", + " [anatomy] 'jug'\n", + " [anatomy] 'ular'\n", + " [concept] 'central'\n", + " [anatomy] 've'\n", + " [anatomy] 'nous'\n", + " [disorder_present] 'line'\n", + " [concept] 'internal'\n", + " [anatomy] 'jug'\n", + " [anatomy] 'ular'\n", + " [disorder_present] 'sheath'\n", + " [concept] 'two'\n", + " [anatomy] 'media'\n", + " [anatomy] 'sti'\n", + " [anatomy] 'nal'\n", + " [disorder_present] 'drains'\n", + " [anatomy] 'stern'\n", + " [anatomy] 'oto'\n", + " [disorder_present] 'my'\n", + " [disorder_present] 'wires'\n", + " [anatomy] 'media'\n", + " [concept] 'sti'\n", + " [concept] 'nal'\n", + " [concept] 'surgical'\n", + " [disorder_present] 'clips'\n", + " [anatomy] 'Lung'\n", + " [concept] 'volumes'\n", + " [concept] 'increased'\n", + " [concept] 'prior'\n", + " [concept] 'decreased'\n", + " [anatomy] 'pulmonary'\n", + " [disorder_present] 'ed'\n", + " [disorder_present] 'ema'\n", + " [concept] 'decreased'\n", + " [anatomy] 'bi'\n", + " [anatomy] 'bas'\n", + " [anatomy] 'ila'\n", + " [concept] 'r'\n", + " [disorder_present] 'ate'\n", + " [anatomy] 'le'\n", + " [anatomy] 'cta'\n", + " [disorder_present] 'sis'\n", + " [concept] 'Small'\n", + " [concept] 'bilateral'\n", + " [disorder_present] 'e'\n", + " [disorder_present] 'usions'\n", + " [concept] 'decreased'\n", + " [concept] 'soft'\n", + " [anatomy] 'tissue'\n", + " [disorder_present] 'ed'\n", + " [disorder_present] 'ema'\n", + "\n", + "train/patient11162/study5/view1_frontal.jpg: 55 entities\n", + " [concept] 'Persistent'\n", + " [concept] 'small'\n", + " [concept] 'bilateral'\n", + " [anatomy] 'pl'\n", + " [disorder_present] 'eur'\n", + " [anatomy] 'al'\n", + " [disorder_present] 'e'\n", + " [disorder_present] 'usions'\n", + " [concept] 'left'\n", + " [disorder_present] 'e'\n", + " [disorder_present] 'usion'\n", + " [concept] 'slightly'\n", + " [concept] 'greater'\n", + " [concept] 'prior'\n", + " [anatomy] 'Lungs'\n", + " [concept] 'clear'\n", + " [concept] 'Stable'\n", + " [anatomy] 'card'\n", + " [anatomy] 'iom'\n", + " [anatomy] 'ed'\n", + " [anatomy] 'ias'\n", + " [disorder_present] 'tina'\n", + " [anatomy] 'l'\n", + " [concept] 'silhouette'\n", + " [anatomy] 'Cal'\n", + " [anatomy] 'ci'\n", + " [disorder_present] 'fication'\n", + " [anatomy] 'su'\n", + " [anatomy] 'pr'\n", + " [anatomy] 'ah'\n", + " [anatomy] 'ila'\n", + " [anatomy] 'r'\n", + " [anatomy] 'region'\n", + " [anatomy] 'cal'\n", + " [concept] 'fied'\n", + " [anatomy] 'l'\n", + " [anatomy] 'ym'\n", + " [anatomy] 'ph'\n", + " [disorder_present] 'nodes'\n", + " [concept] 'post'\n", + " [concept] 'surgical'\n", + " [concept] 'change'\n", + " [anatomy] 'Bones'\n", + " [concept] 'stable'\n", + " [concept] 'mild'\n", + " [concept] 'de'\n", + " [concept] 'gen'\n", + " [concept] 'erative'\n", + " [concept] 'changes'\n", + " [anatomy] 'spine'\n", + " [anatomy] 'Stern'\n", + " [anatomy] 'oto'\n", + " [disorder_present] 'my'\n", + " [disorder_present] 'wires'\n", + " [concept] 'unchanged'\n", + "\n", + "train/patient11162/study5/view2_lateral.jpg: 55 entities\n", + " [concept] 'Persistent'\n", + " [concept] 'small'\n", + " [concept] 'bilateral'\n", + " [anatomy] 'pl'\n", + " [disorder_present] 'eur'\n", + " [anatomy] 'al'\n", + " [disorder_present] 'e'\n", + " [disorder_present] 'usions'\n", + " [concept] 'left'\n", + " [disorder_present] 'e'\n", + " [disorder_present] 'usion'\n", + " [concept] 'slightly'\n", + " [concept] 'greater'\n", + " [concept] 'prior'\n", + " [anatomy] 'Lungs'\n", + " [concept] 'clear'\n", + " [concept] 'Stable'\n", + " [anatomy] 'card'\n", + " [anatomy] 'iom'\n", + " [anatomy] 'ed'\n", + " [anatomy] 'ias'\n", + " [disorder_present] 'tina'\n", + " [anatomy] 'l'\n", + " [concept] 'silhouette'\n", + " [anatomy] 'Cal'\n", + " [anatomy] 'ci'\n", + " [disorder_present] 'fication'\n", + " [anatomy] 'su'\n", + " [anatomy] 'pr'\n", + " [anatomy] 'ah'\n", + " [anatomy] 'ila'\n", + " [anatomy] 'r'\n", + " [anatomy] 'region'\n", + " [anatomy] 'cal'\n", + " [concept] 'fied'\n", + " [anatomy] 'l'\n", + " [anatomy] 'ym'\n", + " [anatomy] 'ph'\n", + " [disorder_present] 'nodes'\n", + " [concept] 'post'\n", + " [concept] 'surgical'\n", + " [concept] 'change'\n", + " [anatomy] 'Bones'\n", + " [concept] 'stable'\n", + " [concept] 'mild'\n", + " [concept] 'de'\n", + " [concept] 'gen'\n", + " [concept] 'erative'\n", + " [concept] 'changes'\n", + " [anatomy] 'spine'\n", + " [anatomy] 'Stern'\n", + " [anatomy] 'oto'\n", + " [disorder_present] 'my'\n", + " [disorder_present] 'wires'\n", + " [concept] 'unchanged'\n" + ] + } + ], + "source": [ + "# Use only the first 2 reports for BERT demo (heads are randomly initialized)\n", + "BERT_DEMO_N = 5\n", + "\n", + "reports = [v['section_findings'] for v in entity_cache.values()][:BERT_DEMO_N]\n", + "patient_ids = list(entity_cache.keys())[:BERT_DEMO_N]\n", + "\n", + "bert_entities = model.predict_entities(reports, batch_size=2)\n", + "for pid, ents in zip(patient_ids, bert_entities):\n", + " print(f'\\n{pid}: {len(ents)} entities')\n", + " for e in ents:\n", + " print(f\" [{e['type']}] '{e['text']}'\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "d3285116", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "train/patient04528/study1/view2_lateral.jpg: 20 relations\n", + " 'Unchanged' --[modify]--> 'lung'\n", + " 'position' --[modify]--> 'op'\n", + " 'position' --[modify]--> 'lung'\n", + " 'appearance' --[modify]--> 'ex'\n", + " 'appearance' --[modify]--> 'mity'\n", + " 'appearance' --[modify]--> 'ith'\n", + " 'appearance' --[modify]--> 'ora'\n", + " 'appearance' --[modify]--> 'iom'\n", + " 'appearance' --[modify]--> 'ias'\n", + " 'appearance' --[modify]--> 'ing'\n", + " 'appearance' --[modify]--> 'op'\n", + " 'appearance' --[modify]--> 'ac'\n", + " 'appearance' --[modify]--> 'retro'\n", + " 'appearance' --[modify]--> 'iac'\n", + " 'appearance' --[modify]--> 'lung'\n", + " 'appearance' --[modify]--> 'eur'\n", + " 'appearance' --[modify]--> 'al'\n", + " 'appearance' --[modify]--> 'ect'\n", + " 'Absence' --[suggestive_of]--> 'op'\n", + " 'Absence' --[modify]--> 'lung'\n" + ] + } + ], + "source": [ + "bert_relations = model.predict_relations(reports, bert_entities, batch_size=2)\n", + "for pid, rels in zip(patient_ids[:1], bert_relations):\n", + " print(f'\\n{pid}: {len(rels)} relations')\n", + " for r in rels:\n", + " print(f\" '{r['subject']['text']}' --[{r['relation']}]--> '{r['object']['text']}'\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "1a6551ea", + "metadata": {}, + "source": [ + "## Step 6c: Fine-tune the ReXKG NER Head\n", + "\n", + "We build a DataLoader from the PURE-format JSONL training split and run one\n", + "epoch with `pyhealth.trainer.Trainer`. The collate function:\n", + "\n", + "1. Tokenizes each sentence with the model's BERT tokenizer.\n", + "2. Enumerates all candidate spans up to `max_span_length`.\n", + "3. Aligns gold token-level NER labels to the enumerated spans.\n", + "\n", + "**Only the NER head is trained** here — the RE head requires paired\n", + "entity annotations that the standard PURE pipeline supplies separately.\n", + "Set `TRAIN_EPOCHS = 0` to skip and keep the pretrained checkpoint weights.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "9afb7b9a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train sentences: 200 | Val sentences: 60\n", + "ReXKGModel(\n", + " (encoder): BertModel(\n", + " (embeddings): BertEmbeddings(\n", + " (word_embeddings): Embedding(30522, 768, padding_idx=0)\n", + " (position_embeddings): Embedding(512, 768)\n", + " (token_type_embeddings): Embedding(2, 768)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (encoder): BertEncoder(\n", + " (layer): ModuleList(\n", + " (0-11): 12 x BertLayer(\n", + " (attention): BertAttention(\n", + " (self): BertSdpaSelfAttention(\n", + " (query): Linear(in_features=768, out_features=768, bias=True)\n", + " (key): Linear(in_features=768, out_features=768, bias=True)\n", + " (value): Linear(in_features=768, out_features=768, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (output): BertSelfOutput(\n", + " (dense): Linear(in_features=768, out_features=768, bias=True)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): BertIntermediate(\n", + " (dense): Linear(in_features=768, out_features=3072, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): BertOutput(\n", + " (dense): Linear(in_features=3072, out_features=768, bias=True)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (pooler): BertPooler(\n", + " (dense): Linear(in_features=768, out_features=768, bias=True)\n", + " (activation): Tanh()\n", + " )\n", + " )\n", + " (ner_head): _SpanNERHead(\n", + " (hidden_dropout): Dropout(p=0.1, inplace=False)\n", + " (width_embedding): Embedding(9, 150)\n", + " (network): Sequential(\n", + " (0): Linear(in_features=1686, out_features=150, bias=True)\n", + " (1): ReLU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=150, out_features=150, bias=True)\n", + " )\n", + " (output): Linear(in_features=150, out_features=9, bias=True)\n", + " )\n", + " (rel_head): _PairwiseRelationHead(\n", + " (layer_norm): LayerNorm((1536,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " (classifier): Linear(in_features=1536, out_features=4, bias=True)\n", + " )\n", + ")\n", + "ReXKGModel(\n", + " (encoder): BertModel(\n", + " (embeddings): BertEmbeddings(\n", + " (word_embeddings): Embedding(30522, 768, padding_idx=0)\n", + " (position_embeddings): Embedding(512, 768)\n", + " (token_type_embeddings): Embedding(2, 768)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (encoder): BertEncoder(\n", + " (layer): ModuleList(\n", + " (0-11): 12 x BertLayer(\n", + " (attention): BertAttention(\n", + " (self): BertSdpaSelfAttention(\n", + " (query): Linear(in_features=768, out_features=768, bias=True)\n", + " (key): Linear(in_features=768, out_features=768, bias=True)\n", + " (value): Linear(in_features=768, out_features=768, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (output): BertSelfOutput(\n", + " (dense): Linear(in_features=768, out_features=768, bias=True)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): BertIntermediate(\n", + " (dense): Linear(in_features=768, out_features=3072, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): BertOutput(\n", + " (dense): Linear(in_features=3072, out_features=768, bias=True)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (pooler): BertPooler(\n", + " (dense): Linear(in_features=768, out_features=768, bias=True)\n", + " (activation): Tanh()\n", + " )\n", + " )\n", + " (ner_head): _SpanNERHead(\n", + " (hidden_dropout): Dropout(p=0.1, inplace=False)\n", + " (width_embedding): Embedding(9, 150)\n", + " (network): Sequential(\n", + " (0): Linear(in_features=1686, out_features=150, bias=True)\n", + " (1): ReLU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=150, out_features=150, bias=True)\n", + " )\n", + " (output): Linear(in_features=150, out_features=9, bias=True)\n", + " )\n", + " (rel_head): _PairwiseRelationHead(\n", + " (layer_norm): LayerNorm((1536,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " (classifier): Linear(in_features=1536, out_features=4, bias=True)\n", + " )\n", + ")\n", + "ReXKGModel(\n", + " (encoder): BertModel(\n", + " (embeddings): BertEmbeddings(\n", + " (word_embeddings): Embedding(30522, 768, padding_idx=0)\n", + " (position_embeddings): Embedding(512, 768)\n", + " (token_type_embeddings): Embedding(2, 768)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (encoder): BertEncoder(\n", + " (layer): ModuleList(\n", + " (0-11): 12 x BertLayer(\n", + " (attention): BertAttention(\n", + " (self): BertSdpaSelfAttention(\n", + " (query): Linear(in_features=768, out_features=768, bias=True)\n", + " (key): Linear(in_features=768, out_features=768, bias=True)\n", + " (value): Linear(in_features=768, out_features=768, bias=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " (output): BertSelfOutput(\n", + " (dense): Linear(in_features=768, out_features=768, bias=True)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " (intermediate): BertIntermediate(\n", + " (dense): Linear(in_features=768, out_features=3072, bias=True)\n", + " (intermediate_act_fn): GELUActivation()\n", + " )\n", + " (output): BertOutput(\n", + " (dense): Linear(in_features=3072, out_features=768, bias=True)\n", + " (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + " (pooler): BertPooler(\n", + " (dense): Linear(in_features=768, out_features=768, bias=True)\n", + " (activation): Tanh()\n", + " )\n", + " )\n", + " (ner_head): _SpanNERHead(\n", + " (hidden_dropout): Dropout(p=0.1, inplace=False)\n", + " (width_embedding): Embedding(9, 150)\n", + " (network): Sequential(\n", + " (0): Linear(in_features=1686, out_features=150, bias=True)\n", + " (1): ReLU()\n", + " (2): Dropout(p=0.1, inplace=False)\n", + " (3): Linear(in_features=150, out_features=150, bias=True)\n", + " )\n", + " (output): Linear(in_features=150, out_features=9, bias=True)\n", + " )\n", + " (rel_head): _PairwiseRelationHead(\n", + " (layer_norm): LayerNorm((1536,), eps=1e-05, elementwise_affine=True)\n", + " (dropout): Dropout(p=0.1, inplace=False)\n", + " (classifier): Linear(in_features=1536, out_features=4, bias=True)\n", + " )\n", + ")\n", + "Metrics: []\n", + "Metrics: []\n", + "Metrics: []\n", + "Device: cpu\n", + "Device: cpu\n", + "Device: cpu\n", + "\n", + "\n", + "\n", + "Training:\n", + "Training:\n", + "Training:\n", + "Batch size: 4\n", + "Batch size: 4\n", + "Batch size: 4\n", + "Optimizer: \n", + "Optimizer: \n", + "Optimizer: \n", + "Optimizer params: {'lr': 1e-05}\n", + "Optimizer params: {'lr': 1e-05}\n", + "Optimizer params: {'lr': 1e-05}\n", + "Weight decay: 0.0\n", + "Weight decay: 0.0\n", + "Weight decay: 0.0\n", + "Max grad norm: None\n", + "Max grad norm: None\n", + "Max grad norm: None\n", + "Val dataloader: \n", + "Val dataloader: \n", + "Val dataloader: \n", + "Monitor: None\n", + "Monitor: None\n", + "Monitor: None\n", + "Monitor criterion: max\n", + "Monitor criterion: max\n", + "Monitor criterion: max\n", + "Epochs: 5\n", + "Epochs: 5\n", + "Epochs: 5\n", + "Patience: None\n", + "Patience: None\n", + "Patience: None\n", + "\n", + "\n", + "\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a5583712a3a641fba7a92a1beae3e798", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Epoch 0 / 5: 0%| | 0/50 [00:00= 0 and add_left > 0:\n", + " chunk = list(all_sents[j])[-add_left:]\n", + " left_ctx = chunk + left_ctx\n", + " add_left -= len(chunk)\n", + " j -= 1\n", + " right_ctx = []\n", + " j = si + 1\n", + " while j < len(all_sents) and add_right > 0:\n", + " chunk = list(all_sents[j])[:add_right]\n", + " right_ctx += chunk\n", + " add_right -= len(chunk)\n", + " j += 1\n", + " return left_ctx + tokens + right_ctx, len(left_ctx)\n", + "\n", + "\n", + "def _collate(batch):\n", + " tok = model.tokenizer\n", + " max_span = model.max_span_length\n", + "\n", + " ctx_token_lists, sent_starts = [], []\n", + " gold_ent_lists, gold_rel_dicts = [], []\n", + "\n", + " for all_sents, si, gold_ents, gold_rels in batch:\n", + " ctx_tokens, sent_start = _build_context_tokens(all_sents, si, CONTEXT_WINDOW)\n", + " ctx_token_lists.append(ctx_tokens)\n", + " sent_starts.append(sent_start)\n", + " gold_ent_lists.append(gold_ents)\n", + " gold_rel_dicts.append(gold_rels)\n", + "\n", + " enc = tok(\n", + " ctx_token_lists,\n", + " is_split_into_words=True,\n", + " padding=True,\n", + " truncation=True,\n", + " max_length=512,\n", + " return_tensors='pt',\n", + " )\n", + "\n", + " all_spans, all_ner_labels, all_spans_mask = [], [], []\n", + " all_entity_spans, all_rel_labels = [], []\n", + "\n", + " for i, (gold_ents, gold_rels, sent_start) in enumerate(\n", + " zip(gold_ent_lists, gold_rel_dicts, sent_starts)\n", + " ):\n", + " word_ids = enc.word_ids(batch_index=i)\n", + " sent_len = len(batch[i][0][batch[i][1]])\n", + " sent_end = sent_start + sent_len\n", + "\n", + " word_first, word_last = {}, {}\n", + " for pos, wid in enumerate(word_ids):\n", + " if wid is None:\n", + " continue\n", + " if wid not in word_first:\n", + " word_first[wid] = pos\n", + " word_last[wid] = pos\n", + "\n", + " gold_ner_map = {(s, e): lbl for s, e, lbl in gold_ents}\n", + " spans, ner_labels = [], []\n", + "\n", + " for ws in range(sent_start, sent_end):\n", + " for we in range(ws, min(ws + max_span, sent_end)):\n", + " sw = word_first.get(ws)\n", + " ew = word_last.get(we)\n", + " if sw is None or ew is None:\n", + " continue\n", + " width = we - ws\n", + " spans.append([sw, ew, width])\n", + " gold_lbl = gold_ner_map.get((ws - sent_start, we - sent_start))\n", + " ner_labels.append(_ner_label2id.get(gold_lbl, 0))\n", + "\n", + " all_spans.append(spans)\n", + " all_ner_labels.append(ner_labels)\n", + " all_spans_mask.append([1] * len(spans))\n", + "\n", + " # Only keep entities whose subword positions exist (must match entity_spans)\n", + " ent_spans = []\n", + " valid_gold_ents = []\n", + " for ws, we, lbl in gold_ents:\n", + " sw = word_first.get(ws + sent_start)\n", + " ew = word_last.get(we + sent_start)\n", + " if sw is not None and ew is not None:\n", + " ent_spans.append((sw, ew))\n", + " valid_gold_ents.append((ws, we, lbl))\n", + " all_entity_spans.append(ent_spans)\n", + "\n", + " rl = []\n", + " for si_e, (ss, se, _) in enumerate(valid_gold_ents):\n", + " for oi_e, (os_, oe, _) in enumerate(valid_gold_ents):\n", + " if si_e == oi_e:\n", + " continue\n", + " rt = gold_rels.get((ss, se, os_, oe))\n", + " rl.append(_rel_label2id.get(rt, 0))\n", + " all_rel_labels.append(\n", + " torch.tensor(rl, dtype=torch.long) if rl else torch.zeros(0, dtype=torch.long)\n", + " )\n", + "\n", + " max_s = max(len(s) for s in all_spans) if all_spans else 1\n", + " spans_t = torch.zeros(len(batch), max_s, 3, dtype=torch.long)\n", + " labels_t = torch.zeros(len(batch), max_s, dtype=torch.long)\n", + " mask_t = torch.zeros(len(batch), max_s, dtype=torch.long)\n", + " for i, (s, l, m) in enumerate(zip(all_spans, all_ner_labels, all_spans_mask)):\n", + " if s:\n", + " spans_t[i, :len(s)] = torch.tensor(s, dtype=torch.long)\n", + " labels_t[i, :len(l)] = torch.tensor(l, dtype=torch.long)\n", + " mask_t[i, :len(m)] = torch.tensor(m, dtype=torch.long)\n", + "\n", + " return {\n", + " 'input_ids': enc['input_ids'],\n", + " 'attention_mask': enc['attention_mask'],\n", + " 'spans': spans_t,\n", + " 'spans_mask': mask_t,\n", + " 'ner_labels': labels_t,\n", + " 'entity_spans': all_entity_spans,\n", + " 'rel_labels': all_rel_labels,\n", + " }\n", + "\n", + "\n", + "if TRAIN_EPOCHS > 0:\n", + " train_ds = _NERREDataset(TRAIN_FILE)\n", + " val_ds = _NERREDataset(VAL_FILE)\n", + " print(f'Train sentences: {len(train_ds)} | Val sentences: {len(val_ds)}')\n", + "\n", + " train_loader = DataLoader(train_ds, batch_size=TRAIN_BATCH, shuffle=True,\n", + " collate_fn=_collate)\n", + " val_loader = DataLoader(val_ds, batch_size=TRAIN_BATCH, shuffle=False,\n", + " collate_fn=_collate)\n", + "\n", + " trainer = Trainer(model=model, metrics=[])\n", + " trainer.train(\n", + " train_dataloader=train_loader,\n", + " val_dataloader=val_loader,\n", + " epochs=TRAIN_EPOCHS,\n", + " optimizer_params={'lr': 1e-5},\n", + " )\n", + " print('Fine-tuning complete (NER + RE joint loss, context_window=%d).' % CONTEXT_WINDOW)\n", + "else:\n", + " print('TRAIN_EPOCHS=0 — skipping fine-tuning, using checkpoint weights.')\n" + ] + }, + { + "cell_type": "markdown", + "id": "8bdf0619", + "metadata": {}, + "source": [ + "## Step 7: Build and Inspect the Knowledge Graph\n", + "\n", + "`build_kg()` assembles a deduplicated KG:\n", + "- `nodes`: entity nodes (id, text, type)\n", + "- `edges`: relation triples (subject_id, relation, object_id)\n", + "- `subgraphs`: per-study subgraph\n", + "\n", + "Demonstrated with BERT outputs below. Swap in `entity_cache` / `relation_cache` from Steps 4–5 to use GPT results." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "c4adcab0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KG nodes : 114\n", + "KG edges : 31\n", + "\n", + "Nodes:\n", + " [0] Unchanged (concept)\n", + " [1] position (concept)\n", + " [2] left (concept)\n", + " [3] upper (concept)\n", + " [4] ex (anatomy)\n", + " [5] tre (anatomy)\n", + " [6] mity (anatomy)\n", + " [7] PIC (disorder_present)\n", + " [8] C (anatomy)\n", + " [9] line (disorder_present)\n", + " [10] surgical (concept)\n", + " [11] clips (disorder_present)\n", + " [12] projecting (concept)\n", + " [13] hem (anatomy)\n", + " [14] ith (anatomy)\n", + " [15] ora (disorder_present)\n", + " [16] x (disorder_present)\n", + " [17] card (anatomy)\n", + " [18] iom (anatomy)\n", + " [19] ed (anatomy)\n", + " [20] ias (anatomy)\n", + " [21] tina (disorder_present)\n", + " [22] l (anatomy)\n", + " [23] silhouette (concept)\n", + " [24] stable (concept)\n", + " [25] appearance (concept)\n", + " [26] Increased (concept)\n", + " [27] strand (anatomy)\n", + " [28] ing (concept)\n", + " [29] op (disorder_present)\n", + " [30] ac (anatomy)\n", + " [31] ities (disorder_present)\n", + " [32] retro (anatomy)\n", + " [33] iac (anatomy)\n", + " [34] region (anatomy)\n", + " [35] Subtle (concept)\n", + " [36] lung (anatomy)\n", + " [37] zone (anatomy)\n", + " [38] pl (anatomy)\n", + " [39] eur (anatomy)\n", + " [40] al (anatomy)\n", + " [41] significant (concept)\n", + " [42] bony (anatomy)\n", + " [43] abnormalities (disorder_present)\n", + " [44] Absence (concept)\n", + " [45] breast (anatomy)\n", + " [46] shadow (anatomy)\n", + " [47] prior (concept)\n", + " [48] mast (anatomy)\n", + " [49] ect (anatomy)\n", + " [50] omy (disorder_present)\n", + " [51] red (concept)\n", + " [52] emon (anatomy)\n", + " [53] stra (anatomy)\n", + " [54] right (concept)\n", + " [55] internal (concept)\n", + " [56] jug (anatomy)\n", + " [57] ular (anatomy)\n", + " [58] central (concept)\n", + " [59] ve (anatomy)\n", + " [60] nous (anatomy)\n", + " [61] sheath (disorder_present)\n", + " [62] two (concept)\n", + " [63] media (anatomy)\n", + " [64] sti (anatomy)\n", + " [65] nal (anatomy)\n", + " [66] drains (disorder_present)\n", + " [67] stern (anatomy)\n", + " [68] oto (anatomy)\n", + " [69] my (disorder_present)\n", + " [70] wires (disorder_present)\n", + " [71] volumes (concept)\n", + " [72] decreased (concept)\n", + " [73] pulmonary (anatomy)\n", + " [74] ema (disorder_present)\n", + " [75] bi (anatomy)\n", + " [76] bas (anatomy)\n", + " [77] ila (anatomy)\n", + " [78] r (concept)\n", + " [79] ate (disorder_present)\n", + " [80] le (anatomy)\n", + " [81] cta (anatomy)\n", + " [82] sis (disorder_present)\n", + " [83] Small (concept)\n", + " [84] bilateral (concept)\n", + " [85] e (disorder_present)\n", + " [86] usions (disorder_present)\n", + " [87] soft (concept)\n", + " [88] tissue (anatomy)\n", + " [89] Persistent (concept)\n", + " [90] usion (disorder_present)\n", + " [91] slightly (concept)\n", + " [92] greater (concept)\n", + " [93] Lungs (anatomy)\n", + " [94] clear (concept)\n", + " [95] Cal (anatomy)\n", + " [96] ci (anatomy)\n", + " [97] fication (disorder_present)\n", + " [98] su (anatomy)\n", + " [99] pr (anatomy)\n", + " [100] ah (anatomy)\n", + " [101] fied (concept)\n", + " [102] ym (anatomy)\n", + " [103] ph (anatomy)\n", + " [104] nodes (disorder_present)\n", + " [105] post (concept)\n", + " [106] change (concept)\n", + " [107] Bones (anatomy)\n", + " [108] mild (concept)\n", + " [109] de (concept)\n", + " [110] gen (concept)\n", + " [111] erative (concept)\n", + " [112] changes (concept)\n", + " [113] spine (anatomy)\n", + "\n", + "Edges:\n", + " 'Unchanged' --[modify]--> 'lung'\n", + " 'position' --[modify]--> 'op'\n", + " 'position' --[modify]--> 'lung'\n", + " 'appearance' --[modify]--> 'ex'\n", + " 'appearance' --[modify]--> 'mity'\n", + " 'appearance' --[modify]--> 'ith'\n", + " 'appearance' --[modify]--> 'ora'\n", + " 'appearance' --[modify]--> 'iom'\n", + " 'appearance' --[modify]--> 'ias'\n", + " 'appearance' --[modify]--> 'ing'\n", + " 'appearance' --[modify]--> 'op'\n", + " 'appearance' --[modify]--> 'ac'\n", + " 'appearance' --[modify]--> 'retro'\n", + " 'appearance' --[modify]--> 'iac'\n", + " 'appearance' --[modify]--> 'lung'\n", + " 'appearance' --[modify]--> 'eur'\n", + " 'appearance' --[modify]--> 'al'\n", + " 'appearance' --[modify]--> 'ect'\n", + " 'Absence' --[suggestive_of]--> 'op'\n", + " 'Absence' --[modify]--> 'lung'\n", + " 'red' --[modify]--> 'jug'\n", + " 'red' --[modify]--> 've'\n", + " 'red' --[modify]--> 'nous'\n", + " 'red' --[modify]--> 'media'\n", + " 'red' --[modify]--> 'tissue'\n", + " 'jug' --[modify]--> 'jug'\n", + " 'jug' --[modify]--> 'media'\n", + " 'media' --[modify]--> 'jug'\n", + " 'media' --[modify]--> 'media'\n", + " 'Increased' --[modify]--> 'jug'\n", + " 'ed' --[modify]--> 'jug'\n" + ] + } + ], + "source": [ + "kg = model.build_kg(reports=reports, patient_ids=patient_ids)\n", + "\n", + "print(f\"KG nodes : {len(kg['nodes'])}\")\n", + "print(f\"KG edges : {len(kg['edges'])}\")\n", + "\n", + "print('\\nNodes:')\n", + "for n in kg['nodes']:\n", + " print(f\" [{n['id']}] {n['text']} ({n['type']})\")\n", + "\n", + "print('\\nEdges:')\n", + "node_map = {n['id']: n['text'] for n in kg['nodes']}\n", + "for e in kg['edges']:\n", + " print(f\" '{node_map[e['subject_id']]}' --[{e['relation']}]--> '{node_map[e['object_id']]}'\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "860e9d06", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KG saved to /Users/pushpendratiwari/Desktop/ReXKG-main/PyHealth/examples/cxr/rexkg_cache/chexpert_plus_kg_demo.json\n", + "KG saved to /Users/pushpendratiwari/Desktop/ReXKG-main/PyHealth/examples/cxr/rexkg_cache/chexpert_plus_kg_demo.json\n", + "KG saved to /Users/pushpendratiwari/Desktop/ReXKG-main/PyHealth/examples/cxr/rexkg_cache/chexpert_plus_kg_demo.json\n", + "KG saved to /Users/pushpendratiwari/Desktop/ReXKG-main/PyHealth/examples/cxr/rexkg_cache/chexpert_plus_kg_demo.json\n" + ] + } + ], + "source": [ + "kg_out = os.path.join(CACHE_DIR, 'chexpert_plus_kg_demo.json')\n", + "model.save_kg(kg, kg_out)\n", + "print(f'KG saved to {kg_out}')\n" + ] + }, + { + "cell_type": "markdown", + "id": "rexkg-eval-md", + "metadata": {}, + "source": [ + "## Step 9: Evaluate Against Gold Annotations\n", + "\n", + "Uses GPT-extracted entities/relations as **pseudo-gold** annotations to demonstrate\n", + "the `model.evaluate()` pipeline end-to-end.\n", + "\n", + "> **Note**: The bundled `chexpert_plus_groundtruth.json` contains only sentence splits\n", + "> without NER/RE labels, so GPT output is used as a stand-in. For a real benchmark,\n", + "> replace `gold_ents_pseudo` / `gold_rels_pseudo` with annotations from a labelled test set.\n", + "> Reported F1 will be near-zero with randomly initialised BERT heads — fine-tune first.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "rexkg-eval-code", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded 60 test documents from test_tiny.json\n", + "Sentences: 60 | Gold entities: 345 | Gold relations: 251\n", + "\n", + "=== ReXKG Evaluation on Real Test Split ===\n", + "\n", + "ENTITY\n", + " precision : 0.3650\n", + " recall : 0.5681\n", + " f1 : 0.4444\n", + " tp : 196\n", + " fp : 341\n", + " fn : 149\n", + "\n", + "RELATION\n", + " precision : 0.0000\n", + " recall : 0.0000\n", + " f1 : 0.0000\n", + " tp : 0\n", + " fp : 64\n", + " fn : 251\n" + ] + } + ], + "source": [ + "# Step 9 — Evaluate on real test split (src/ner/data/data_split/test_tiny.json)\n", + "# Matching is surface-text + type (avoids BERT-subword vs word-index mismatch).\n", + "import os, json\n", + "from pyhealth.metrics.rexkg import rexkg_metrics\n", + "\n", + "TEST_FILE = os.path.abspath(\n", + " os.path.join(PYHEALTH_DIR, '..', 'src', 'ner', 'data', 'data_split', 'test_tiny.json')\n", + ")\n", + "# Swap to 'test.json' for the full 560-doc evaluation.\n", + "\n", + "test_samples = []\n", + "with open(TEST_FILE) as f:\n", + " for line in f:\n", + " test_samples.append(json.loads(line.strip()))\n", + "print(f'Loaded {len(test_samples)} test documents from {os.path.basename(TEST_FILE)}')\n", + "\n", + "# Build sentence texts and gold annotation dicts\n", + "texts, gold_entity_lists, gold_relation_lists = [], [], []\n", + "for doc in test_samples:\n", + " for sent_tokens, sent_ner, sent_rel in zip(\n", + " doc['sentences'], doc['ner'], doc['relations']\n", + " ):\n", + " text = ' '.join(sent_tokens)\n", + " texts.append(text)\n", + "\n", + " # Gold entities: {\"text\": ..., \"type\": ...}\n", + " gold_ents = [\n", + " {'text': ' '.join(sent_tokens[s:e+1]), 'type': lbl}\n", + " for s, e, lbl in sent_ner\n", + " ]\n", + " gold_entity_lists.append(gold_ents)\n", + "\n", + " # Gold relations: {\"subject\": {\"text\":...}, \"object\": {\"text\":...}, \"relation\": ...}\n", + " tok_to_ent = {(s, e): {'text': ' '.join(sent_tokens[s:e+1]), 'type': lbl}\n", + " for s, e, lbl in sent_ner}\n", + " gold_rels = [\n", + " {\n", + " 'subject': tok_to_ent.get((ss, se), {'text': ' '.join(sent_tokens[ss:se+1]), 'type': 'concept'}),\n", + " 'object': tok_to_ent.get((os, oe), {'text': ' '.join(sent_tokens[os:oe+1]), 'type': 'concept'}),\n", + " 'relation': rt,\n", + " }\n", + " for ss, se, os, oe, rt in sent_rel\n", + " ]\n", + " gold_relation_lists.append(gold_rels)\n", + "\n", + "total_gold_ents = sum(len(g) for g in gold_entity_lists)\n", + "total_gold_rels = sum(len(g) for g in gold_relation_lists)\n", + "print(f'Sentences: {len(texts)} | Gold entities: {total_gold_ents} | Gold relations: {total_gold_rels}')\n", + "\n", + "# Run model inference\n", + "pred_entity_lists = model.predict_entities(texts)\n", + "pred_relation_lists = model.predict_relations(texts, pred_entity_lists)\n", + "\n", + "metrics = rexkg_metrics(pred_entity_lists, gold_entity_lists, pred_relation_lists, gold_relation_lists)\n", + "\n", + "print('\\n=== ReXKG Evaluation on Real Test Split ===')\n", + "for task, scores in metrics.items():\n", + " print(f'\\n{task.upper()}')\n", + " for k, v in scores.items():\n", + " if isinstance(v, float):\n", + " print(f' {k:12s}: {v:.4f}')\n", + " else:\n", + " print(f' {k:12s}: {v}')\n" + ] + }, + { + "cell_type": "markdown", + "id": "de44bb71", + "metadata": {}, + "source": [ + "## Step 8: (Optional) Visualize the Subgraph" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "39b87589", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/h2/k71ywfpx2174hnh5fw8gd0dh0000gn/T/ipykernel_10057/999882383.py:26: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + " plt.tight_layout()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Showing 27 nodes, 31 edges (full graph: 27 nodes, 31 edges)\n" + ] + } + ], + "source": [ + "try:\n", + " import networkx as nx\n", + " import matplotlib.pyplot as plt\n", + "\n", + " TOP_N_NODES = 100\n", + "# show only the top-N most-connected nodes\n", + "\n", + " G_full = nx.DiGraph()\n", + " node_map = {n['id']: n['text'] for n in kg['nodes']}\n", + " for e in kg['edges']:\n", + " G_full.add_edge(node_map[e['subject_id']], node_map[e['object_id']], label=e['relation'])\n", + "\n", + " # Keep only the TOP_N_NODES nodes with the highest degree\n", + " top_nodes = sorted(G_full.degree, key=lambda x: x[1], reverse=True)[:TOP_N_NODES]\n", + " top_node_names = {n for n, _ in top_nodes}\n", + " G = G_full.subgraph(top_node_names).copy()\n", + "\n", + " pos = nx.spring_layout(G, seed=42, k=1.5)\n", + " edge_labels = nx.get_edge_attributes(G, 'label')\n", + "\n", + " plt.figure(figsize=(14, 9))\n", + " nx.draw(G, pos, with_labels=True, node_size=1800, node_color='lightblue',\n", + " font_size=8, arrows=True, arrowsize=15)\n", + " nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=7)\n", + " plt.title(f'ReXKG Knowledge Graph - Top {TOP_N_NODES} nodes (CheXpert Plus Demo)')\n", + " plt.tight_layout()\n", + " plt.show()\n", + " print(f'Showing {G.number_of_nodes()} nodes, {G.number_of_edges()} edges '\n", + " f'(full graph: {G_full.number_of_nodes()} nodes, {G_full.number_of_edges()} edges)')\n", + "except ImportError:\n", + " print('pip install networkx matplotlib')\n" + ] + }, + { + "cell_type": "markdown", + "id": "23634394", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "| Step | Component | What it does |\n", + "|------|-----------|-------------|\n", + "| 1 | Path setup | Auto-locates `pyhealth/` package; sets `DATA_ROOT` and `CACHE_DIR` |\n", + "| 2 | `CheXpertPlusDataset` | Loads CheXpert Plus CSV; one study per row |\n", + "| 3 | `RadiologyKGExtractionTask` | Converts findings text into structured samples |\n", + "| 4 | GPT-4o entity extraction | Few-shot NER on small subset; cached to JSON |\n", + "| 5 | GPT-4o relation extraction | Few-shot RE on entity dict; cached to JSON |\n", + "| 6 | `ReXKGModel` | BERT encoder + span NER head + pairwise RE head |\n", + "| 6b | `predict_entities/relations` | BERT-based inference at scale |\n", + "| 7 | `build_kg` / `save_kg` | Assembles and serialises deduplicated KG |\n", + "| 8 | NetworkX | Optional subgraph visualisation |\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e972c8d2-42d7-4892-aa04-066e82c58b28", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/cxr/rexkg_cache/.gitignore b/examples/cxr/rexkg_cache/.gitignore new file mode 100644 index 000000000..90278a3a6 --- /dev/null +++ b/examples/cxr/rexkg_cache/.gitignore @@ -0,0 +1,3 @@ +# Ignore runtime cache files produced by the notebook +* +!.gitignore diff --git a/pyhealth/datasets/__init__.py b/pyhealth/datasets/__init__.py index 50b1b3887..4a1a17451 100644 --- a/pyhealth/datasets/__init__.py +++ b/pyhealth/datasets/__init__.py @@ -49,6 +49,7 @@ def __init__(self, *args, **kwargs): from .base_dataset import BaseDataset from .cardiology import CardiologyDataset from .chestxray14 import ChestXray14Dataset +from .chexpert_plus import CheXpertPlusDataset from .clinvar import ClinVarDataset from .cosmic import COSMICDataset from .covid19_cxr import COVID19CXRDataset diff --git a/pyhealth/datasets/chexpert_plus.py b/pyhealth/datasets/chexpert_plus.py new file mode 100644 index 000000000..192efa66b --- /dev/null +++ b/pyhealth/datasets/chexpert_plus.py @@ -0,0 +1,121 @@ +""" +PyHealth dataset for the CheXpert Plus dataset. + +Dataset link: + https://stanfordaimi.azurewebsites.net/datasets/5158c524-d3ab-4e02-96e9-6ee9efc110a1 + +Dataset paper: + Chambon, P., et al. "CheXpert Plus: Augmenting a Large Chest X-ray Dataset with + Text Radiology Reports, Patient Demographics and Additional Image Format." + arXiv:2405.19111 (2024). + +Dataset paper link: + https://arxiv.org/abs/2405.19111 + +ReXKG paper: + Li, Z., et al. "ReXKG: A Structured Radiology Report Knowledge Graph for + Chest X-ray Analysis." arXiv:2408.14397 (2024). + +ReXKG paper link: + https://arxiv.org/abs/2408.14397 + +Authors: + Aaron Miller (aaronm6@illinois.edu) + Kathryn Thompson (kyt3@illinois.edu) + Pushpendra Tiwari (pkt3@illinois.edu) +""" + +import logging +import os +from pathlib import Path +from typing import Optional + +from pyhealth.datasets import BaseDataset +from pyhealth.tasks import RadiologyKGExtractionTask + +logger = logging.getLogger(__name__) + + +class CheXpertPlusDataset(BaseDataset): + """Dataset class for the CheXpert Plus chest X-ray report dataset. + + CheXpert Plus augments the original CheXpert dataset with structured + free-text radiology reports. Each record corresponds to a single chest + X-ray study identified by its image path. This class exposes the + ``section_findings`` text for downstream NLP/NER/KG tasks. + + Attributes: + root (str): Root directory containing ``df_chexpert_plus_240401.csv``. + dataset_name (str): Name of the dataset. + config_path (str): Path to the YAML configuration file. + + Example:: + >>> dataset = CheXpertPlusDataset(root="/path/to/chexpert_plus") + >>> print(dataset.stats()) + """ + + def __init__( + self, + root: str = ".", + config_path: Optional[str] = str( + Path(__file__).parent / "configs" / "chexpert_plus.yaml" + ), + **kwargs, + ) -> None: + """Initializes the CheXpert Plus dataset. + + Args: + root (str): Root directory that contains + ``df_chexpert_plus_240401.csv``. Defaults to the working + directory. + config_path (Optional[str]): Path to the YAML configuration file. + Defaults to the bundled ``configs/chexpert_plus.yaml``. + **kwargs: Additional keyword arguments forwarded to + :class:`~pyhealth.datasets.BaseDataset`. + + Raises: + FileNotFoundError: If the CSV file is not found under ``root``. + + Example:: + >>> dataset = CheXpertPlusDataset(root="./data") + """ + self._csv_path = os.path.join(root, "df_chexpert_plus_240401.csv") + self._verify_data(root) + + super().__init__( + root=root, + tables=["chexpert_plus"], + dataset_name="CheXpertPlus", + config_path=config_path, + **kwargs, + ) + + @property + def default_task(self) -> RadiologyKGExtractionTask: + """Returns the default KG extraction task for this dataset. + + Returns: + RadiologyKGExtractionTask: Entity and relation extraction task. + + Example:: + >>> dataset = CheXpertPlusDataset(root="./data") + >>> task = dataset.default_task + """ + return RadiologyKGExtractionTask() + + def _verify_data(self, root: str) -> None: + """Verifies the presence of the required CSV file. + + Args: + root (str): Root directory to check. + + Raises: + FileNotFoundError: If ``df_chexpert_plus_240401.csv`` is missing. + """ + if not os.path.isfile(self._csv_path): + raise FileNotFoundError( + f"CheXpert Plus CSV not found at '{self._csv_path}'. " + "Download the dataset from " + "https://stanfordaimi.azurewebsites.net/datasets/" + "5158c524-d3ab-4e02-96e9-6ee9efc110a1" + ) diff --git a/pyhealth/datasets/configs/chexpert_plus.yaml b/pyhealth/datasets/configs/chexpert_plus.yaml new file mode 100644 index 000000000..0d3520442 --- /dev/null +++ b/pyhealth/datasets/configs/chexpert_plus.yaml @@ -0,0 +1,14 @@ +# Authors: Aaron Miller (aaronm6@illinois.edu), Kathryn Thompson (kyt3@illinois.edu), Pushpendra Tiwari (pkt3@illinois.edu) +version: "1.0" +tables: + chexpert_plus: + file_path: "df_chexpert_plus_240401.csv" + patient_id: "path_to_image" + timestamp: null + attributes: + - "path_to_image" + - "section_findings" + - "section_impression" + - "section_history" + - "section_comparison" + join: [] diff --git a/pyhealth/metrics/__init__.py b/pyhealth/metrics/__init__.py index da8da0f5b..10b95d082 100644 --- a/pyhealth/metrics/__init__.py +++ b/pyhealth/metrics/__init__.py @@ -13,6 +13,7 @@ # from .fairness import fairness_metrics_fn from .ranking import ranking_metrics_fn from .regression import regression_metrics_fn +from .rexkg import rexkg_metrics __all__ = [ "binary_metrics_fn", diff --git a/pyhealth/metrics/rexkg.py b/pyhealth/metrics/rexkg.py new file mode 100644 index 000000000..34133e3f4 --- /dev/null +++ b/pyhealth/metrics/rexkg.py @@ -0,0 +1,127 @@ +"""Surface-level evaluation metrics for the ReXKG NER and RE tasks. + +Entity F1: an entity is correct if its surface text AND type both match +the gold annotation exactly (case-insensitive). + +Relation F1: a relation is correct if the subject text, object text, AND +relation type all match the gold annotation exactly (case-insensitive). + +This text-based matching avoids tokenisation-index mismatches when comparing +BERT-subword model output against word-tokenised gold annotations. +""" + +from typing import Dict, List, Tuple + + +def _entity_f1( + pred: List[List[Dict]], + gold: List[List[Dict]], +) -> Dict[str, float]: + """Compute micro-averaged entity F1. + + Args: + pred: One list of entity dicts per document. Each dict must have + ``"start"`` (int), ``"end"`` (int), ``"type"`` (str). + gold: Same structure as *pred* but for gold annotations. + + Returns: + Dict with keys ``"precision"``, ``"recall"``, ``"f1"``, + ``"tp"``, ``"fp"``, ``"fn"``. + """ + tp = fp = fn = 0 + for pred_doc, gold_doc in zip(pred, gold): + pred_set = {(e["text"].lower(), e["type"]) for e in pred_doc} + gold_set = {(e["text"].lower(), e["type"]) for e in gold_doc} + tp += len(pred_set & gold_set) + fp += len(pred_set - gold_set) + fn += len(gold_set - pred_set) + + precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0 + recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0 + f1 = ( + 2 * precision * recall / (precision + recall) + if (precision + recall) > 0 + else 0.0 + ) + return {"precision": precision, "recall": recall, "f1": f1, "tp": tp, "fp": fp, "fn": fn} + + +def _relation_f1( + pred: List[List[Dict]], + gold: List[List[Dict]], +) -> Dict[str, float]: + """Compute micro-averaged relation F1. + + Args: + pred: One list of relation dicts per document. Each dict must have + ``"subject"`` (dict with ``"start"``, ``"end"``), + ``"object"`` (dict with ``"start"``, ``"end"``), + ``"relation"`` (str). + gold: Same structure as *pred*. + + Returns: + Dict with keys ``"precision"``, ``"recall"``, ``"f1"``, + ``"tp"``, ``"fp"``, ``"fn"``. + """ + tp = fp = fn = 0 + for pred_doc, gold_doc in zip(pred, gold): + def _rel_key(r: Dict) -> Tuple: + return ( + r["subject"]["text"].lower(), + r["object"]["text"].lower(), + r["relation"], + ) + + pred_set = {_rel_key(r) for r in pred_doc} + gold_set = {_rel_key(r) for r in gold_doc} + tp += len(pred_set & gold_set) + fp += len(pred_set - gold_set) + fn += len(gold_set - pred_set) + + precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0 + recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0 + f1 = ( + 2 * precision * recall / (precision + recall) + if (precision + recall) > 0 + else 0.0 + ) + return {"precision": precision, "recall": recall, "f1": f1, "tp": tp, "fp": fp, "fn": fn} + + +def rexkg_metrics( + pred_entities: List[List[Dict]], + gold_entities: List[List[Dict]], + pred_relations: List[List[Dict]], + gold_relations: List[List[Dict]], +) -> Dict[str, Dict[str, float]]: + """Compute both entity and relation F1 for a batch of documents. + + Args: + pred_entities: Predicted entities per document (from + :meth:`~pyhealth.models.ReXKGModel.predict_entities`). + gold_entities: Gold entity annotations per document; each entity + dict must have ``"start"``, ``"end"``, ``"type"``. + pred_relations: Predicted relations per document (from + :meth:`~pyhealth.models.ReXKGModel.predict_relations`). + gold_relations: Gold relation annotations per document; each dict + must have ``"subject"`` (with ``"start"``/``"end"``), + ``"object"`` (with ``"start"``/``"end"``), ``"relation"``. + + Returns: + Dict with keys ``"entity"`` and ``"relation"``, each containing + ``"precision"``, ``"recall"``, ``"f1"``, ``"tp"``, ``"fp"``, ``"fn"``. + + Example:: + + >>> from pyhealth.metrics.rexkg import rexkg_metrics + >>> gold_ents = [[{"start": 0, "end": 1, "type": "anatomy"}]] + >>> pred_ents = [[{"start": 0, "end": 1, "type": "anatomy"}]] + >>> gold_rels = [[]] + >>> pred_rels = [[]] + >>> rexkg_metrics(pred_ents, gold_ents, pred_rels, gold_rels) + {'entity': {'precision': 1.0, 'recall': 1.0, 'f1': 1.0, 'tp': 1, 'fp': 0, 'fn': 0}, 'relation': {'precision': 0.0, 'recall': 0.0, 'f1': 0.0, 'tp': 0, 'fp': 0, 'fn': 0}} + """ + return { + "entity": _entity_f1(pred_entities, gold_entities), + "relation": _relation_f1(pred_relations, gold_relations), + } diff --git a/pyhealth/models/__init__.py b/pyhealth/models/__init__.py index 4c168d3e3..101e6f213 100644 --- a/pyhealth/models/__init__.py +++ b/pyhealth/models/__init__.py @@ -21,6 +21,7 @@ from .mlp import MLP from .molerec import MoleRec, MoleRecLayer from .retain import MultimodalRETAIN, RETAIN, RETAINLayer +from .rexkg import ReXKGModel from .rnn import MultimodalRNN, RNN, RNNLayer from .safedrug import SafeDrug, SafeDrugLayer from .sparcnet import DenseBlock, DenseLayer, SparcNet, TransitionLayer diff --git a/pyhealth/models/rexkg.py b/pyhealth/models/rexkg.py new file mode 100644 index 000000000..946691098 --- /dev/null +++ b/pyhealth/models/rexkg.py @@ -0,0 +1,765 @@ +""" +PyHealth model for radiology knowledge graph extraction (ReXKG). + +Implements a span-based named entity recognition (NER) model and a pairwise +relation extractor on top of a BERT backbone, following the PURE architecture +used in the original ReXKG paper. A lightweight KG builder is included to +convert model predictions into a structured knowledge graph compatible with the +rest of the ReXKG pipeline. + +ReXKG paper: (please cite if you use this module) + Li, Z., et al. "ReXKG: A Structured Radiology Report Knowledge Graph for + Chest X-ray Analysis." arXiv:2408.14397 (2024). + +ReXKG paper link: + https://arxiv.org/abs/2408.14397 + +Authors: + Aaron Miller (aaronm6@illinois.edu) + Kathryn Thompson (kyt3@illinois.edu) + Pushpendra Tiwari (pkt3@illinois.edu) +""" + +import json +import logging +from collections import defaultdict +from typing import Dict, List, Optional, Tuple + +import torch +import torch.nn as nn +from transformers import AutoModel, AutoTokenizer + +from pyhealth.datasets import SampleDataset +from pyhealth.models import BaseModel +from pyhealth.tasks.rexkg_extraction import NER_LABELS, RELATION_TYPES + +logger = logging.getLogger(__name__) + +# --------------------------------------------------------------------------- +# Constants +# --------------------------------------------------------------------------- + +_NER_LABEL2ID: Dict[str, int] = {lbl: i + 1 for i, lbl in enumerate(NER_LABELS)} +_NER_ID2LABEL: Dict[int, str] = {v: k for k, v in _NER_LABEL2ID.items()} +_NER_ID2LABEL[0] = "O" # index 0 → outside / non-entity + +_REL_LABEL2ID: Dict[str, int] = {lbl: i + 1 for i, lbl in enumerate(RELATION_TYPES)} +_REL_ID2LABEL: Dict[int, str] = {v: k for k, v in _REL_LABEL2ID.items()} +_REL_ID2LABEL[0] = "none" + + +# --------------------------------------------------------------------------- +# Sub-modules +# --------------------------------------------------------------------------- + + +class _SpanNERHead(nn.Module): + """Span-based NER classification head. + + For each candidate span ``[start, end]`` in a sentence this head + produces a distribution over :data:`NER_LABELS` + the ``"O"`` class. + + The span representation is constructed by concatenating: + * the BERT hidden state of the *start* token, + * the BERT hidden state of the *end* token, and + * a learned width embedding for the span length. + + Args: + hidden_size (int): BERT hidden dimension. + num_ner_labels (int): Number of entity types (including ``"O"``). + width_embedding_dim (int): Dimension for the span-width embedding. + max_span_length (int): Maximum span length (in tokens). + dropout (float): Dropout probability applied before the classifier. + """ + + def __init__( + self, + hidden_size: int, + num_ner_labels: int, + width_embedding_dim: int = 150, + max_span_length: int = 8, + span_hidden_dim: int = 150, + dropout: float = 0.2, + ) -> None: + super().__init__() + self.hidden_dropout = nn.Dropout(dropout) + self.width_embedding = nn.Embedding( + max_span_length + 1, width_embedding_dim + ) + span_input_dim = hidden_size * 2 + width_embedding_dim + # Mirror the original checkpoint's 2-part structure: + # network: Linear(span_input_dim → span_hidden_dim) → ReLU → Dropout → Linear(hidden → hidden) + # output: Linear(span_hidden_dim → num_ner_labels) + # This allows the NER checkpoint to load with exact key matches. + self.network = nn.Sequential( + nn.Linear(span_input_dim, span_hidden_dim), + nn.ReLU(), + nn.Dropout(dropout), + nn.Linear(span_hidden_dim, span_hidden_dim), + ) + self.output = nn.Linear(span_hidden_dim, num_ner_labels) + + def forward( + self, + sequence_output: torch.Tensor, + spans: torch.Tensor, + ) -> torch.Tensor: + """Compute NER logits for a batch of spans. + + Args: + sequence_output (torch.Tensor): BERT output of shape + ``(batch, seq_len, hidden_size)``. + spans (torch.Tensor): Span indices of shape + ``(batch, num_spans, 3)`` where the last dim is + ``[start, end, width]``. + + Returns: + torch.Tensor: Logits of shape ``(batch, num_spans, num_ner_labels)``. + """ + start_idx = spans[:, :, 0] # (B, S) + end_idx = spans[:, :, 1] # (B, S) + width = spans[:, :, 2] # (B, S) + + batch_size, seq_len, hidden = sequence_output.size() + seq = self.hidden_dropout(sequence_output) + start_rep = seq[ + torch.arange(batch_size).unsqueeze(1), start_idx + ] # (B, S, H) + end_rep = seq[ + torch.arange(batch_size).unsqueeze(1), end_idx + ] # (B, S, H) + + width_rep = self.width_embedding(width) # (B, S, W) + span_rep = torch.cat([start_rep, end_rep, width_rep], dim=-1) + return self.output(self.network(span_rep)) + + +class _PairwiseRelationHead(nn.Module): + """Pairwise relation classification head. + + For each ordered entity pair ``(subject, object)`` this head predicts + a distribution over :data:`RELATION_TYPES` + the ``"none"`` class. + + The pair representation is the concatenation of the **start-token** + representations of the subject and object spans, matching the original + PURE ``BertForRelation`` architecture (``sub_idx`` / ``obj_idx`` are + single token positions, not average pools). + + Args: + hidden_size (int): BERT hidden dimension. + num_rel_labels (int): Number of relation types (including ``"none"``). + dropout (float): Dropout probability applied before the classifier. + """ + + def __init__( + self, + hidden_size: int, + num_rel_labels: int, + dropout: float = 0.1, + ) -> None: + super().__init__() + self.layer_norm = nn.LayerNorm(hidden_size * 2) + self.dropout = nn.Dropout(dropout) + self.classifier = nn.Linear(hidden_size * 2, num_rel_labels) + + def forward( + self, + sequence_output: torch.Tensor, + entity_spans: List[List[Tuple[int, int]]], + ) -> List[torch.Tensor]: + """Compute relation logits for all entity pairs in the batch. + + Args: + sequence_output (torch.Tensor): BERT output of shape + ``(batch, seq_len, hidden_size)``. + entity_spans (List[List[Tuple[int, int]]]): For each sentence in + the batch a list of ``(start, end)`` index tuples identifying + predicted entity spans. + + Returns: + List[torch.Tensor]: One logit tensor per sentence of shape + ``(num_pairs, num_rel_labels)``. An empty list is returned for + sentences with fewer than two predicted entities. + """ + results = [] + for i, spans in enumerate(entity_spans): + if len(spans) < 2: + results.append( + torch.zeros( + 0, + self.classifier.out_features, + device=sequence_output.device, + dtype=sequence_output.dtype, + ) + ) + continue + + # start token of each entity span → subject/object representation + span_reps = torch.stack( + [sequence_output[i, start] for start, _end in spans] + ) # (E, H) + + # All ordered pairs (subject, object) + sub_idx = [] + obj_idx = [] + for s in range(len(spans)): + for o in range(len(spans)): + if s != o: + sub_idx.append(s) + obj_idx.append(o) + + pairs = torch.cat( + [span_reps[sub_idx], span_reps[obj_idx]], dim=-1 + ) # (P, 2H) + pairs = self.layer_norm(pairs) + pairs = self.dropout(pairs) + results.append(self.classifier(pairs)) + return results + + +# --------------------------------------------------------------------------- +# Main model +# --------------------------------------------------------------------------- + + +class ReXKGModel(BaseModel): + """Radiology Knowledge Graph extraction model (ReXKG). + + Jointly trains a span-based NER head and a pairwise relation extraction + head on top of a shared BERT encoder. After inference, :meth:`build_kg` + converts the predicted entities and relations into a structured knowledge + graph in the format used by the rest of the ReXKG pipeline. + + Architecture (PURE-based): + + * **Encoder**: pre-trained BERT (``bert-base-uncased`` by default). + * **NER head**: span representation (start + end + width embedding) fed + through a two-layer MLP → entity-type logits. + * **RE head**: start-token entity pair representation fed through a + two-layer MLP → relation-type logits. + * **KG builder**: entity merging + deduplication + size-relation + extraction → JSON-serialisable KG. + + Args: + dataset (SampleDataset): The processed sample dataset produced by + :meth:`~pyhealth.datasets.CheXpertPlusDataset.set_task`. + bert_model_name (str): HuggingFace model id for the BERT encoder. + Defaults to ``"bert-base-uncased"``. + max_span_length (int): Maximum span length considered during NER. + Defaults to ``8``. + width_embedding_dim (int): Dimension of the span-width embedding. + Defaults to ``150``. + ner_dropout (float): Dropout for the NER head. Defaults to ``0.1``. + rel_dropout (float): Dropout for the RE head. Defaults to ``0.1``. + context_window (int): Number of tokens to include as left/right + context when encoding a sentence. Defaults to ``100``. + + Example:: + >>> from pyhealth.datasets import CheXpertPlusDataset + >>> from pyhealth.tasks import RadiologyKGExtractionTask + >>> from pyhealth.models import ReXKGModel + >>> + >>> base = CheXpertPlusDataset(root="/path/to/chexpert_plus") + >>> samples = base.set_task(RadiologyKGExtractionTask()) + >>> model = ReXKGModel(dataset=samples) + >>> kg = model.build_kg(reports=["No acute cardiopulmonary process."]) + """ + + def __init__( + self, + dataset: Optional[SampleDataset] = None, + bert_model_name: str = "bert-base-uncased", + max_span_length: int = 8, + width_embedding_dim: int = 150, + span_hidden_dim: int = 150, + ner_dropout: float = 0.1, + rel_dropout: float = 0.1, + ) -> None: + super().__init__(dataset) + + self.bert_model_name = bert_model_name + self.max_span_length = max_span_length + + # BERT encoder + self.encoder = AutoModel.from_pretrained(bert_model_name) + self.tokenizer = AutoTokenizer.from_pretrained(bert_model_name) + hidden_size: int = self.encoder.config.hidden_size + + # Task heads + num_ner_labels = len(NER_LABELS) + 1 # +1 for "O" + num_rel_labels = len(RELATION_TYPES) + 1 # +1 for "none" + self.ner_head = _SpanNERHead( + hidden_size=hidden_size, + num_ner_labels=num_ner_labels, + width_embedding_dim=width_embedding_dim, + max_span_length=max_span_length, + span_hidden_dim=span_hidden_dim, + dropout=ner_dropout, + ) + self.rel_head = _PairwiseRelationHead( + hidden_size=hidden_size, + num_rel_labels=num_rel_labels, + dropout=rel_dropout, + ) + + # ------------------------------------------------------------------ + # Helpers + # ------------------------------------------------------------------ + + def _encode( + self, input_ids: torch.Tensor, attention_mask: torch.Tensor + ) -> torch.Tensor: + """Run the BERT encoder and return the last hidden states. + + Args: + input_ids (torch.Tensor): Token ids of shape ``(B, L)``. + attention_mask (torch.Tensor): Attention mask of shape ``(B, L)``. + + Returns: + torch.Tensor: BERT last hidden states of shape ``(B, L, H)``. + """ + outputs = self.encoder( + input_ids=input_ids, + attention_mask=attention_mask, + return_dict=True, + ) + return outputs.last_hidden_state + + def _enumerate_spans( + self, seq_len: int + ) -> List[Tuple[int, int, int]]: + """Enumerate all valid spans ``(start, end, width)`` for a sequence. + + Args: + seq_len (int): Number of tokens in the sequence (excluding + ``[CLS]`` / ``[SEP]``). + + Returns: + List[Tuple[int, int, int]]: Each tuple is ``(start, end, width)`` + with ``1 <= width <= max_span_length``. + """ + spans = [] + for start in range(seq_len): + for end in range(start, min(start + self.max_span_length, seq_len)): + width = end - start + 1 + spans.append((start, end, width)) + return spans + + # ------------------------------------------------------------------ + # Forward + # ------------------------------------------------------------------ + + def forward(self, **kwargs) -> Dict[str, torch.Tensor]: + """Forward pass returning NER and relation logits. + + Expects the following keys in ``kwargs``: + + * ``input_ids`` (torch.Tensor): ``(B, L)`` + * ``attention_mask`` (torch.Tensor): ``(B, L)`` + * ``spans`` (torch.Tensor): ``(B, num_spans, 3)`` — each row is + ``[start, end, width]`` (pre-computed by the collate function). + * ``ner_labels`` (torch.Tensor, optional): ``(B, num_spans)`` NER + label indices. When provided the NER loss is included. + * ``spans_mask`` (torch.Tensor, optional): ``(B, num_spans)`` binary + mask; 1 for real spans, 0 for padding. Used for loss masking. + Defaults to all-ones when absent. + * ``entity_spans`` (List[List[Tuple[int,int]]], optional): Gold entity + span ``(start, end)`` pairs per sentence (1-indexed, CLS-inclusive). + Required for RE training. + * ``rel_labels`` (List[torch.Tensor], optional): For each sentence, + a 1-D tensor of relation-type label ids for every ordered + ``(subject, object)`` pair over ``entity_spans``. Label ``0`` + means ``"none"``. Required for RE training. + + Returns: + Dict[str, torch.Tensor]: A dict with keys: + + * ``"ner_logits"`` — shape ``(B, num_spans, num_ner_labels)`` + * ``"ner_loss"`` — scalar, present only when ``ner_labels`` given + * ``"rel_loss"`` — scalar, present only when ``rel_labels`` given + * ``"loss"`` — sum of ner_loss + rel_loss (for Trainer) + """ + input_ids = kwargs["input_ids"] + attention_mask = kwargs["attention_mask"] + spans = kwargs["spans"] + + sequence_output = self._encode(input_ids, attention_mask) + ner_logits = self.ner_head(sequence_output, spans) + + out: Dict[str, torch.Tensor] = {"ner_logits": ner_logits} + total_loss = None + + if "ner_labels" in kwargs: + ner_labels = kwargs["ner_labels"] + spans_mask = kwargs.get( + "spans_mask", + torch.ones(ner_labels.shape, dtype=torch.long, device=ner_labels.device), + ) + # Match original: CrossEntropyLoss(reduction='sum') with active-span masking + loss_fct = nn.CrossEntropyLoss(reduction="sum") + B, S, C = ner_logits.size() + active = spans_mask.view(-1) == 1 + active_logits = ner_logits.view(B * S, C)[active] + active_labels = ner_labels.view(B * S)[active] + ner_loss = loss_fct(active_logits, active_labels) + out["ner_loss"] = ner_loss + total_loss = ner_loss + + if "entity_spans" in kwargs and "rel_labels" in kwargs: + entity_spans = kwargs["entity_spans"] # List[List[(start,end)]] + rel_labels_list = kwargs["rel_labels"] # List[Tensor] + rel_logits_list = self.rel_head(sequence_output, entity_spans) + rel_loss_fct = nn.CrossEntropyLoss() + rel_losses = [] + for logits, labels in zip(rel_logits_list, rel_labels_list): + if logits.numel() > 0 and labels.numel() > 0: + rel_losses.append(rel_loss_fct(logits, labels.to(logits.device))) + if rel_losses: + rel_loss = torch.stack(rel_losses).mean() + out["rel_loss"] = rel_loss + total_loss = rel_loss if total_loss is None else total_loss + rel_loss + + if total_loss is not None: + out["loss"] = total_loss # pyhealth.Trainer expects "loss" + + return out + + # ------------------------------------------------------------------ + # Inference helpers + # ------------------------------------------------------------------ + + @torch.no_grad() + def predict_entities( + self, texts: List[str], batch_size: int = 32 + ) -> List[List[Dict]]: + """Run NER inference on a list of radiology report texts. + + Args: + texts (List[str]): Raw report strings. + batch_size (int): Number of reports per GPU batch. + + Returns: + List[List[Dict]]: One list per report; each dict contains: + + * ``"start"`` (int): Start token index. + * ``"end"`` (int): End token index. + * ``"text"`` (str): Surface form of the entity. + * ``"type"`` (str): Predicted entity type from :data:`NER_LABELS`. + """ + self.eval() + device = self.device + all_entities: List[List[Dict]] = [] + + for batch_start in range(0, len(texts), batch_size): + batch_texts = texts[batch_start : batch_start + batch_size] + + encoding = self.tokenizer( + batch_texts, + padding=True, + truncation=True, + max_length=512, + return_offsets_mapping=True, + return_tensors="pt", + ) + input_ids = encoding["input_ids"].to(device) + attention_mask = encoding["attention_mask"].to(device) + offset_mapping = encoding["offset_mapping"] + + sequence_output = self._encode(input_ids, attention_mask) + + for i, text in enumerate(batch_texts): + seq_len = int(attention_mask[i].sum().item()) - 2 # strip CLS/SEP + if seq_len <= 0: + all_entities.append([]) + continue + + raw_spans = self._enumerate_spans(seq_len) + if not raw_spans: + all_entities.append([]) + continue + + span_tensor = torch.tensor( + raw_spans, dtype=torch.long, device=device + ).unsqueeze(0) # (1, S, 3), token indices exclude CLS/SEP + ner_span_tensor = span_tensor.clone() + ner_span_tensor[..., 0:2] += 1 # shift start/end to align with CLS-inclusive sequence_output + + ner_logits = self.ner_head( + sequence_output[i].unsqueeze(0), ner_span_tensor + ) # (1, S, num_labels) + pred_ids = ner_logits.squeeze(0).argmax(dim=-1) # (S,) + + entities = [] + offsets = offset_mapping[i] # (L, 2) + for span_idx, (start_tok, end_tok, _width) in enumerate(raw_spans): + label_id = pred_ids[span_idx].item() + if label_id == 0: + continue # "O" — not an entity + # Map token indices → char offsets + char_start = offsets[start_tok + 1][0].item() # +1 for CLS + char_end = offsets[end_tok + 1][1].item() + entity_text = text[char_start:char_end].strip() + if entity_text: + entities.append( + { + "start": start_tok, + "end": end_tok, + "text": entity_text, + "type": _NER_ID2LABEL[label_id], + } + ) + all_entities.append(entities) + + return all_entities + + @torch.no_grad() + def predict_relations( + self, + texts: List[str], + entity_lists: List[List[Dict]], + batch_size: int = 32, + ) -> List[List[Dict]]: + """Run relation extraction inference given predicted entities. + + Args: + texts (List[str]): Raw report strings (same order as + ``entity_lists``). + entity_lists (List[List[Dict]]): NER predictions from + :meth:`predict_entities`. + batch_size (int): Number of reports per GPU batch. + + Returns: + List[List[Dict]]: One list per report; each dict contains: + + * ``"subject"`` (Dict): Subject entity. + * ``"object"`` (Dict): Object entity. + * ``"relation"`` (str): Predicted relation type. + """ + self.eval() + device = self.device + all_relations: List[List[Dict]] = [] + + for batch_start in range(0, len(texts), batch_size): + batch_texts = texts[batch_start : batch_start + batch_size] + batch_entities = entity_lists[batch_start : batch_start + batch_size] + + encoding = self.tokenizer( + batch_texts, + padding=True, + truncation=True, + max_length=512, + return_tensors="pt", + ) + input_ids = encoding["input_ids"].to(device) + attention_mask = encoding["attention_mask"].to(device) + + sequence_output = self._encode(input_ids, attention_mask) + + entity_spans_batch = [ + [(e["start"] + 1, e["end"] + 1) for e in ents] # +1 for CLS + for ents in batch_entities + ] + rel_logits_batch = self.rel_head(sequence_output, entity_spans_batch) + + for i, (entities, rel_logits) in enumerate( + zip(batch_entities, rel_logits_batch) + ): + relations: List[Dict] = [] + if len(entities) < 2 or rel_logits.numel() == 0: + all_relations.append(relations) + continue + + pred_ids = rel_logits.argmax(dim=-1) + pair_idx = 0 + for s in range(len(entities)): + for o in range(len(entities)): + if s == o: + continue + rel_id = pred_ids[pair_idx].item() + if rel_id != 0: # 0 → "none" + relations.append( + { + "subject": entities[s], + "object": entities[o], + "relation": _REL_ID2LABEL[rel_id], + } + ) + pair_idx += 1 + all_relations.append(relations) + + return all_relations + + # ------------------------------------------------------------------ + # KG builder + # ------------------------------------------------------------------ + + def build_kg( + self, + reports: List[str], + patient_ids: Optional[List[str]] = None, + batch_size: int = 32, + ) -> Dict: + """Run the full ReXKG pipeline on a list of radiology reports. + + Executes NER → relation extraction → KG construction in sequence and + returns a structured knowledge graph dict. + + Args: + reports (List[str]): Raw radiology report texts. + patient_ids (Optional[List[str]]): Optional study identifiers used + as keys in the output KG. If ``None``, integer indices are + used. + batch_size (int): Batch size for BERT inference. + + Returns: + Dict: A knowledge graph with the following top-level keys: + + * ``"nodes"`` (List[Dict]): Unique entity nodes, each with + ``"id"``, ``"text"``, and ``"type"``. + * ``"edges"`` (List[Dict]): Relation edges, each with + ``"subject_id"``, ``"object_id"``, and ``"relation"``. + * ``"subgraphs"`` (Dict[str, Dict]): Per-study subgraph containing + ``"entities"`` and ``"relations"`` for that study. + + Example:: + >>> kg = model.build_kg( + ... reports=["Mild cardiomegaly is present."], + ... patient_ids=["patient01/study1/view1.jpg"], + ... ) + >>> kg["nodes"][0] + {'id': 0, 'text': 'cardiomegaly', 'type': 'Observation'} + """ + if patient_ids is None: + patient_ids = [str(i) for i in range(len(reports))] + elif len(patient_ids) != len(reports): + raise ValueError( + "patient_ids and reports must have the same length; " + f"got {len(patient_ids)} patient_ids and {len(reports)} reports." + ) + + entity_lists = self.predict_entities(reports, batch_size=batch_size) + relation_lists = self.predict_relations( + reports, entity_lists, batch_size=batch_size + ) + + # Build global node registry (deduplicate by normalised surface form) + node_text_to_id: Dict[str, int] = {} + nodes: List[Dict] = [] + + def _get_or_add_node(entity: Dict) -> int: + key = entity["text"].lower().strip() + if key not in node_text_to_id: + node_id = len(nodes) + node_text_to_id[key] = node_id + nodes.append( + {"id": node_id, "text": entity["text"], "type": entity["type"]} + ) + return node_text_to_id[key] + + edges: List[Dict] = [] + seen_edges = set() + subgraphs: Dict[str, Dict] = {} + + for pid, entities, relations in zip( + patient_ids, entity_lists, relation_lists + ): + sub_entity_ids = [_get_or_add_node(e) for e in entities] + sub_edges = [] + for rel in relations: + subj_id = _get_or_add_node(rel["subject"]) + obj_id = _get_or_add_node(rel["object"]) + edge_key = (subj_id, obj_id, rel["relation"]) + if edge_key not in seen_edges: + seen_edges.add(edge_key) + edge = { + "subject_id": subj_id, + "object_id": obj_id, + "relation": rel["relation"], + } + edges.append(edge) + sub_edges.append(edge) + + subgraphs[pid] = { + "entities": [nodes[i] for i in sub_entity_ids], + "relations": sub_edges, + } + + return {"nodes": nodes, "edges": edges, "subgraphs": subgraphs} + + def save_kg(self, kg: Dict, output_path: str) -> None: + """Serialize a KG dict produced by :meth:`build_kg` to a JSON file. + + Args: + kg (Dict): KG dict as returned by :meth:`build_kg`. + output_path (str): Destination file path (will be created or + overwritten). + """ + with open(output_path, "w", encoding="utf-8") as f: + json.dump(kg, f, indent=2, ensure_ascii=False) + logger.info("KG saved to %s", output_path) + + def evaluate( + self, + texts: List[str], + gold_entities: List[List[Dict]], + gold_relations: Optional[List[List[Dict]]] = None, + batch_size: int = 32, + ) -> Dict[str, Dict[str, float]]: + """Evaluate entity and relation extraction against gold annotations. + + Computes span-level micro-averaged precision, recall, and F1 for both + NER and (optionally) RE. A predicted entity is correct only when its + span *and* type exactly match the gold annotation. A predicted + relation is correct when subject span, object span, *and* relation + type all match exactly. + + Args: + texts (List[str]): Raw report strings in the same order as the + gold annotation lists. + gold_entities (List[List[Dict]]): Gold entity annotations; one + list per document. Each entity dict must contain: + + * ``"start"`` (int): Token start index. + * ``"end"`` (int): Token end index. + * ``"type"`` (str): Entity type string. + + gold_relations (List[List[Dict]], optional): Gold relation + annotations; one list per document. Each relation dict must + contain: + + * ``"subject"`` (Dict): Dict with ``"start"`` and ``"end"``. + * ``"object"`` (Dict): Dict with ``"start"`` and ``"end"``. + * ``"relation"`` (str): Relation type string. + + When *None*, relation F1 is computed against empty gold sets + (all predicted relations will count as false positives). + batch_size (int): Batch size passed to :meth:`predict_entities` + and :meth:`predict_relations`. + + Returns: + Dict with two keys: + + * ``"entity"`` — dict with ``precision``, ``recall``, ``f1``, + ``tp``, ``fp``, ``fn``. + * ``"relation"`` — same structure (zero if *gold_relations* is + ``None``). + + Example:: + + >>> metrics = model.evaluate(texts, gold_entities, gold_relations) + >>> print(f"Entity F1: {metrics['entity']['f1']:.3f}") + >>> print(f"Relation F1: {metrics['relation']['f1']:.3f}") + """ + from pyhealth.metrics.rexkg import rexkg_metrics + + pred_entities = self.predict_entities(texts, batch_size=batch_size) + pred_relations = self.predict_relations( + texts, pred_entities, batch_size=batch_size + ) + + if gold_relations is None: + gold_relations = [[] for _ in texts] + + return rexkg_metrics( + pred_entities, gold_entities, pred_relations, gold_relations + ) diff --git a/pyhealth/tasks/__init__.py b/pyhealth/tasks/__init__.py index a32618f9c..4254509a1 100644 --- a/pyhealth/tasks/__init__.py +++ b/pyhealth/tasks/__init__.py @@ -12,6 +12,7 @@ from .chestxray14_binary_classification import ChestXray14BinaryClassification from .chestxray14_multilabel_classification import ChestXray14MultilabelClassification from .covid19_cxr_classification import COVID19CXRClassification +from .rexkg_extraction import RadiologyKGExtractionTask from .deid_ner import DeIDNERTask from .dka import DKAPredictionMIMIC4, T1DDKAPredictionMIMIC4 from .drug_recommendation import ( diff --git a/pyhealth/tasks/rexkg_extraction.py b/pyhealth/tasks/rexkg_extraction.py new file mode 100644 index 000000000..73379d2f3 --- /dev/null +++ b/pyhealth/tasks/rexkg_extraction.py @@ -0,0 +1,152 @@ +""" +PyHealth task for radiology knowledge graph extraction using the CheXpert Plus +dataset and the ReXKG pipeline. + +Dataset paper: (please cite if you use this dataset) + Chambon, P., et al. "CheXpert Plus: Augmenting a Large Chest X-ray Dataset + with Text Radiology Reports, Patient Demographics and Additional Image + Format." arXiv:2405.19111 (2024). + +ReXKG paper: (please also cite when using this task) + Li, Z., et al. "ReXKG: A Structured Radiology Report Knowledge Graph for + Chest X-ray Analysis." arXiv:2408.14397 (2024). + +Authors: + Aaron Miller (aaronm6@illinois.edu) + Kathryn Thompson (kyt3@illinois.edu) + Pushpendra Tiwari (pkt3@illinois.edu) +""" + +import logging +from typing import Dict, List, Optional + +from pyhealth.data import Event, Patient +from pyhealth.tasks import BaseTask + +logger = logging.getLogger(__name__) + +# NER labels used by the ReXKG PURE-based extractor (task: mimic01). +# Order must match src/ner/shared/const.py task_ner_labels['mimic01'] +# so that checkpoint label IDs align correctly. +NER_LABELS: List[str] = [ + "size", + "anatomy", + "disorder_present", + "disorder_notpresent", + "concept", + "procedures", + "devices_present", + "devices_notpresent", +] + +# Relation types (task: mimic01) — must match const.py task_rel_labels['mimic01']. +RELATION_TYPES: List[str] = ["located_at", "suggestive_of", "modify"] + + +class RadiologyKGExtractionTask(BaseTask): + """PyHealth task for extracting entities and relations from radiology + reports to build a structured knowledge graph (ReXKG pipeline). + + Each sample contains the raw findings text for one radiology study. The + model is expected to: + + 1. Identify named entities (NER) from :attr:`NER_LABELS`. + 2. Classify pairwise relations between entity spans (:attr:`RELATION_TYPES`). + 3. (Optional) Link entities to UMLS concepts and build a KG. + + This task is intentionally kept label-free at the task level — the NER and + relation labels are produced by the model at inference time, not by a + supervised classification head over fixed classes. Consequently, + ``output_schema`` uses ``"sequence"`` to store the raw predicted spans and + relations as structured dicts. + + Attributes: + task_name (str): Identifier for the task. + input_schema (Dict[str, str]): Maps ``"text"`` to ``"str"``. + output_schema (Dict[str, str]): Maps ``"entities"`` and + ``"relations"`` to ``"sequence"``. + + Examples: + >>> from pyhealth.datasets import CheXpertPlusDataset + >>> from pyhealth.tasks import RadiologyKGExtractionTask + >>> dataset = CheXpertPlusDataset(root="/path/to/chexpert_plus") + >>> task = RadiologyKGExtractionTask() + >>> sample_dataset = dataset.set_task(task) + """ + + task_name: str = "RadiologyKGExtraction" + input_schema: Dict[str, str] = {"text": "raw"} + output_schema: Dict[str, str] = { + "entities": "raw", + "relations": "raw", + } + + def __init__( + self, + findings_only: bool = True, + min_text_length: int = 10, + ) -> None: + """Initializes the RadiologyKGExtractionTask. + + Args: + findings_only (bool): If ``True`` (default), only the + ``section_findings`` field is used as input text. Set to + ``False`` to concatenate ``section_impression`` as well. + min_text_length (int): Minimum character length for a report to be + included. Reports shorter than this threshold are skipped. + Defaults to 10. + """ + super().__init__() + self.findings_only = findings_only + self.min_text_length = min_text_length + + def __call__(self, patient: Patient) -> List[Dict]: + """Generates extraction samples for a single patient (study). + + Args: + patient (Patient): A patient object containing one or more + ``chexpert_plus`` events. + + Returns: + List[Dict]: One dict per event with keys: + + - ``"patient_id"`` (str): The study image path used as the + patient identifier. + - ``"text"`` (str): The radiology findings text. + - ``"entities"`` (list): Empty list at task-construction time; + populated by the model during inference. + - ``"relations"`` (list): Empty list at task-construction time; + populated by the model during inference. + + Example:: + >>> samples = task(patient) + >>> samples[0]["text"] + 'No acute cardiopulmonary process...' + """ + events: List[Event] = patient.get_events(event_type="chexpert_plus") + + samples = [] + for event in events: + findings = (event["section_findings"] if "section_findings" in event else None) or "" + impression = (event["section_impression"] if "section_impression" in event else None) or "" + + if self.findings_only: + text = findings.strip() + else: + parts = [s.strip() for s in [findings, impression] if s.strip()] + text = " ".join(parts) + + if len(text) < self.min_text_length: + continue + + samples.append( + { + "patient_id": patient.patient_id, + "text": text, + # Populated by ReXKGModel at inference time + "entities": [], + "relations": [], + } + ) + + return samples diff --git a/tests/test_chexpert_plus.py b/tests/test_chexpert_plus.py new file mode 100644 index 000000000..c67ece717 --- /dev/null +++ b/tests/test_chexpert_plus.py @@ -0,0 +1,87 @@ +"""Tests for CheXpertPlusDataset. + +Run with: + pytest tests/test_chexpert_plus.py -v +""" + +import os +import tempfile + +import pandas as pd +import pytest + +from pyhealth.datasets import CheXpertPlusDataset + + +# --------------------------------------------------------------------------- +# Fixtures +# --------------------------------------------------------------------------- + + +@pytest.fixture +def chexpert_plus_root(tmp_path): + """Create a minimal CheXpert Plus CSV in a temporary directory.""" + data = { + "path_to_image": [ + "train/patient00001/study1/view1_frontal.jpg", + "train/patient00002/study1/view1_frontal.jpg", + "train/patient00003/study1/view1_frontal.jpg", + ], + "section_findings": [ + "No acute cardiopulmonary process.", + "Mild cardiomegaly is noted. Lungs are clear.", + "Small left pleural effusion. No pneumothorax.", + ], + "section_impression": [ + "Normal chest radiograph.", + "Cardiomegaly.", + "Left pleural effusion.", + ], + "section_history": ["Cough.", "Shortness of breath.", "Chest pain."], + "section_comparison": ["None.", "Prior study 2021.", "None."], + } + df = pd.DataFrame(data) + csv_path = tmp_path / "df_chexpert_plus_240401.csv" + df.to_csv(csv_path, index=False) + return str(tmp_path) + + +# --------------------------------------------------------------------------- +# Tests +# --------------------------------------------------------------------------- + + +def test_init_raises_without_csv(tmp_path): + """Dataset should raise FileNotFoundError when CSV is absent.""" + with pytest.raises(FileNotFoundError): + CheXpertPlusDataset(root=str(tmp_path)) + + +def test_init_succeeds_with_csv(chexpert_plus_root): + """Dataset should initialise without errors when CSV is present.""" + dataset = CheXpertPlusDataset(root=chexpert_plus_root, dev=True) + assert dataset.dataset_name == "CheXpertPlus" + + +def test_default_task_type(chexpert_plus_root): + """default_task should return a RadiologyKGExtractionTask.""" + from pyhealth.tasks import RadiologyKGExtractionTask + + dataset = CheXpertPlusDataset(root=chexpert_plus_root, dev=True) + task = dataset.default_task + assert isinstance(task, RadiologyKGExtractionTask) + + +def test_patient_ids_populated(chexpert_plus_root): + """There should be one patient per row (path_to_image as patient_id).""" + dataset = CheXpertPlusDataset(root=chexpert_plus_root, dev=True) + patient_ids = dataset.unique_patient_ids + assert len(patient_ids) == 3 + + +def test_stats_runs(chexpert_plus_root, capsys): + """stats() should not raise and should print dataset information.""" + dataset = CheXpertPlusDataset(root=chexpert_plus_root, dev=True) + dataset.stats() + captured = capsys.readouterr() + assert "CheXpertPlus" in captured.out diff --git a/tests/test_rexkg.py b/tests/test_rexkg.py new file mode 100644 index 000000000..bad9c3b7b --- /dev/null +++ b/tests/test_rexkg.py @@ -0,0 +1,190 @@ +"""Tests for ReXKGModel (NER head, relation head, and KG builder). + +Run with: + pytest tests/test_rexkg.py -v +""" + +import pytest +import torch + +from pyhealth.models.rexkg import ( + ReXKGModel, + _NER_ID2LABEL, + _REL_ID2LABEL, + NER_LABELS, + RELATION_TYPES, +) +from pyhealth.tasks.rexkg_extraction import RadiologyKGExtractionTask + + +# --------------------------------------------------------------------------- +# Fixtures +# --------------------------------------------------------------------------- + + +@pytest.fixture(scope="module") +def model(): + """Instantiate ReXKGModel without a SampleDataset (inference only).""" + return ReXKGModel( + dataset=None, + bert_model_name="bert-base-uncased", + max_span_length=4, + ) + + +SAMPLE_REPORTS = [ + "No acute cardiopulmonary process.", + "Mild cardiomegaly. Small left pleural effusion is noted.", +] + + +# --------------------------------------------------------------------------- +# Label maps +# --------------------------------------------------------------------------- + + +def test_ner_label_count(): + """NER label map must cover all labels plus the 'O' class.""" + assert len(_NER_ID2LABEL) == len(NER_LABELS) + 1 + assert _NER_ID2LABEL[0] == "O" + + +def test_rel_label_count(): + """Relation label map must cover all types plus 'none'.""" + assert len(_REL_ID2LABEL) == len(RELATION_TYPES) + 1 + assert _REL_ID2LABEL[0] == "none" + + +# --------------------------------------------------------------------------- +# Task +# --------------------------------------------------------------------------- + + +def test_task_schema(): + task = RadiologyKGExtractionTask() + assert "text" in task.input_schema + assert "entities" in task.output_schema + assert "relations" in task.output_schema + + +def test_task_skips_short_text(): + """Reports shorter than min_text_length should be excluded.""" + from pyhealth.data import Patient + + task = RadiologyKGExtractionTask(min_text_length=50) + + # Build a minimal mock Patient + class _MockEvent(dict): + pass + + class _MockPatient: + patient_id = "p001" + + def get_events(self, event_type): + evt = _MockEvent() + evt["chexpert_plus/section_findings"] = "Short." + evt["chexpert_plus/section_impression"] = "" + return [evt] + + samples = task(_MockPatient()) + assert samples == [] + + +# --------------------------------------------------------------------------- +# Model: NER head +# --------------------------------------------------------------------------- + + +def test_model_predict_entities_returns_list(model): + """predict_entities should return one list per input report.""" + results = model.predict_entities(SAMPLE_REPORTS, batch_size=2) + assert len(results) == len(SAMPLE_REPORTS) + for entity_list in results: + assert isinstance(entity_list, list) + + +def test_model_entity_dict_keys(model): + """Each predicted entity must have the required keys.""" + results = model.predict_entities(SAMPLE_REPORTS[:1]) + for entity in results[0]: + assert {"start", "end", "text", "type"} == set(entity.keys()) + assert entity["type"] in NER_LABELS + + +# --------------------------------------------------------------------------- +# Model: RE head +# --------------------------------------------------------------------------- + + +def test_model_predict_relations_returns_list(model): + """predict_relations should return one list per input report.""" + entity_lists = model.predict_entities(SAMPLE_REPORTS, batch_size=2) + rel_lists = model.predict_relations(SAMPLE_REPORTS, entity_lists, batch_size=2) + assert len(rel_lists) == len(SAMPLE_REPORTS) + + +def test_model_relation_dict_keys(model): + """Each predicted relation must have subject, object, and relation keys.""" + entity_lists = model.predict_entities(SAMPLE_REPORTS) + rel_lists = model.predict_relations(SAMPLE_REPORTS, entity_lists) + for rel_list in rel_lists: + for rel in rel_list: + assert {"subject", "object", "relation"} == set(rel.keys()) + assert rel["relation"] in RELATION_TYPES + + +# --------------------------------------------------------------------------- +# Model: KG builder +# --------------------------------------------------------------------------- + + +def test_build_kg_structure(model): + """build_kg should return a dict with nodes, edges, and subgraphs.""" + kg = model.build_kg(SAMPLE_REPORTS, patient_ids=["p001", "p002"]) + assert "nodes" in kg + assert "edges" in kg + assert "subgraphs" in kg + assert set(kg["subgraphs"].keys()) == {"p001", "p002"} + + +def test_build_kg_node_deduplication(model): + """Identical entities across reports should map to the same node.""" + reports = [ + "Cardiomegaly is present.", + "Cardiomegaly is noted bilaterally.", + ] + kg = model.build_kg(reports, patient_ids=["a", "b"]) + + matching_nodes = [ + n + for n in kg["nodes"] + if str( + n.get("text") + or n.get("label") + or n.get("name") + or n.get("entity") + or "" + ).lower() + == "cardiomegaly" + ] + assert len(matching_nodes) == 1 + + shared_node_id = matching_nodes[0]["id"] + for patient_id in ["a", "b"]: + subgraph = kg["subgraphs"][patient_id] + if isinstance(subgraph, dict) and "nodes" in subgraph: + subgraph_node_ids = [ + node["id"] if isinstance(node, dict) else node + for node in subgraph["nodes"] + ] + assert shared_node_id in subgraph_node_ids +def test_save_kg(model, tmp_path): + """save_kg should write a valid JSON file.""" + import json + + kg = model.build_kg(SAMPLE_REPORTS[:1]) + out = str(tmp_path / "kg_test.json") + model.save_kg(kg, out) + with open(out) as f: + loaded = json.load(f) + assert "nodes" in loaded