-- :material-tools:{ .lg .middle } __FHIR-native ML Pipelines__
+- :material-tools:{ .lg .middle } __FHIR-native Pipelines__
---
diff --git a/docs/reference/io/containers/dataset.md b/docs/reference/io/containers/dataset.md
index 731e5310..af2bd421 100644
--- a/docs/reference/io/containers/dataset.md
+++ b/docs/reference/io/containers/dataset.md
@@ -27,14 +27,12 @@ print("Columns:", dataset.columns)
validation_result = dataset.validate(schema="path/to/schema.yaml")
print("Validation Result:", validation_result)
-# 4. Run inference using your ML model
-predictions = model.predict(dataset.data)
-probabilities = model.predict_proba(dataset.data)[:, 1]
+# 4. Run inference using your ML model and store in metadata
+dataset.metadata["predictions"] = model.predict(dataset.data)
+dataset.metadata["probabilities"] = model.predict_proba(dataset.data)[:, 1]
# 5. Convert predictions to FHIR RiskAssessment resources for downstream use
risk_assessments = dataset.to_risk_assessment(
- predictions=predictions,
- probabilities=probabilities,
outcome_code="A41.9",
outcome_display="Sepsis, unspecified",
model_name="SepsisRiskModel",
diff --git a/healthchain/fhir/__init__.py b/healthchain/fhir/__init__.py
index 9193ccd4..b33116d2 100644
--- a/healthchain/fhir/__init__.py
+++ b/healthchain/fhir/__init__.py
@@ -23,6 +23,7 @@
from healthchain.fhir.readers import (
create_resource_from_dict,
convert_prefetch_to_fhir_objects,
+ prefetch_to_bundle,
read_content_attachment,
)
@@ -74,6 +75,7 @@
# Conversions and readers
"create_resource_from_dict",
"convert_prefetch_to_fhir_objects",
+ "prefetch_to_bundle",
"read_content_attachment",
# Bundle operations
"create_bundle",
diff --git a/healthchain/fhir/readers.py b/healthchain/fhir/readers.py
index 7d7bbd06..d55fe7be 100644
--- a/healthchain/fhir/readers.py
+++ b/healthchain/fhir/readers.py
@@ -37,6 +37,34 @@ def create_resource_from_dict(
return None
+def prefetch_to_bundle(prefetch: Dict[str, Any]) -> Dict[str, Any]:
+ """Flatten CDS Hooks prefetch into a collection Bundle dict.
+
+ Converts the keyed prefetch format (used in CDS Hooks) into a flat bundle
+ suitable for Dataset.from_fhir_bundle().
+
+ Args:
+ prefetch: CDS Hooks prefetch dict with format:
+ {"patient": {...}, "observations": {"entry": [...]}, ...}
+
+ Returns:
+ Bundle dict with type "collection" and flattened entries
+
+ Example:
+ >>> prefetch = request.prefetch
+ >>> bundle = prefetch_to_bundle(prefetch)
+ >>> dataset = Dataset.from_fhir_bundle(bundle, schema=schema)
+ """
+ entries = []
+ for key, value in prefetch.items():
+ if isinstance(value, dict):
+ if "entry" in value: # Searchset bundle
+ entries.extend(value["entry"])
+ elif "resourceType" in value: # Single resource
+ entries.append({"resource": value})
+ return {"type": "collection", "entry": entries}
+
+
def convert_prefetch_to_fhir_objects(
prefetch_dict: Dict[str, Any],
) -> Dict[str, Resource]:
diff --git a/healthchain/io/containers/dataset.py b/healthchain/io/containers/dataset.py
index 39740be5..20a4e36c 100644
--- a/healthchain/io/containers/dataset.py
+++ b/healthchain/io/containers/dataset.py
@@ -1,7 +1,7 @@
import pandas as pd
import numpy as np
-from dataclasses import dataclass
+from dataclasses import dataclass, field
from pathlib import Path
from typing import Any, Dict, Iterator, List, Union, Optional
@@ -23,6 +23,10 @@ class Dataset(DataContainer[pd.DataFrame]):
"""
A container for tabular data optimized for ML inference, lightweight wrapper around a pandas DataFrame.
+ Attributes:
+ data: The pandas DataFrame containing the dataset.
+ metadata: Dict for storing pipeline results (predictions, probabilities, etc.)
+
Methods:
from_csv: Load Dataset from CSV.
from_dict: Load Dataset from dict.
@@ -31,6 +35,8 @@ class Dataset(DataContainer[pd.DataFrame]):
to_risk_assessment: Convert predictions to FHIR RiskAssessment.
"""
+ metadata: Dict[str, Any] = field(default_factory=dict)
+
def __post_init__(self):
if not isinstance(self.data, pd.DataFrame):
raise TypeError("data must be a pandas DataFrame")
@@ -194,8 +200,6 @@ def _dtypes_compatible(self, actual: str, expected: str) -> bool:
def to_risk_assessment(
self,
- predictions: np.ndarray,
- probabilities: np.ndarray,
outcome_code: str,
outcome_display: str,
outcome_system: str = "http://hl7.org/fhir/sid/icd-10",
@@ -203,6 +207,8 @@ def to_risk_assessment(
model_version: Optional[str] = None,
high_threshold: float = 0.7,
moderate_threshold: float = 0.4,
+ predictions: Optional[np.ndarray] = None,
+ probabilities: Optional[np.ndarray] = None,
) -> List[RiskAssessment]:
"""Convert model predictions to FHIR RiskAssessment resources.
@@ -210,8 +216,6 @@ def to_risk_assessment(
including in FHIR Bundles or sending to FHIR servers.
Args:
- predictions: Binary predictions array (0/1)
- probabilities: Probability scores array (0-1)
outcome_code: Code for the predicted outcome (e.g., "A41.9" for sepsis)
outcome_display: Display text for the outcome (e.g., "Sepsis")
outcome_system: Code system for the outcome (default: ICD-10)
@@ -219,22 +223,31 @@ def to_risk_assessment(
model_version: Version of the ML model (optional)
high_threshold: Threshold for high risk (default: 0.7)
moderate_threshold: Threshold for moderate risk (default: 0.4)
+ predictions: Binary predictions array (0/1). Defaults to metadata["predictions"]
+ probabilities: Probability scores array (0-1). Defaults to metadata["probabilities"]
Returns:
List of RiskAssessment resources, one per patient
Example:
- >>> predictions = np.array([0, 1, 0])
- >>> probabilities = np.array([0.15, 0.85, 0.32])
>>> risk_assessments = dataset.to_risk_assessment(
- ... predictions,
- ... probabilities,
... outcome_code="A41.9",
... outcome_display="Sepsis, unspecified",
... model_name="RandomForest",
... model_version="1.0"
... )
"""
+ # Fall back to metadata if not provided
+ if predictions is None:
+ predictions = self.metadata.get("predictions")
+ if probabilities is None:
+ probabilities = self.metadata.get("probabilities")
+
+ if predictions is None or probabilities is None:
+ raise ValueError(
+ "predictions and probabilities must be provided or available in metadata"
+ )
+
if len(predictions) != len(self.data):
raise ValueError(
f"Predictions length ({len(predictions)}) must match "
diff --git a/healthchain/sandbox/sandboxclient.py b/healthchain/sandbox/sandboxclient.py
index da121501..c3f59576 100644
--- a/healthchain/sandbox/sandboxclient.py
+++ b/healthchain/sandbox/sandboxclient.py
@@ -464,7 +464,7 @@ def send_requests(self) -> List[Dict]:
log.debug(f"Making POST request to: {self.url}")
response = client.post(
url=str(self.url),
- json=request.model_dump(exclude_none=True),
+ json=request.model_dump(exclude_none=True, mode="json"),
timeout=timeout,
)
response.raise_for_status()
@@ -472,7 +472,9 @@ def send_requests(self) -> List[Dict]:
try:
response_data = response.json()
cds_response = CDSResponse(**response_data)
- responses.append(cds_response.model_dump(exclude_none=True))
+ responses.append(
+ cds_response.model_dump(mode="json", exclude_none=True)
+ )
except json.JSONDecodeError:
log.error(
f"Invalid JSON response from {self.url}. "
@@ -507,51 +509,56 @@ def send_requests(self) -> List[Dict]:
return responses
- def save_results(self, directory: Union[str, Path] = "./output/") -> None:
+ def save_results(
+ self,
+ directory: Union[str, Path] = "./output/",
+ save_request: bool = True,
+ save_response: bool = True,
+ ) -> None:
"""
- Save request and response data to disk.
+ Save request and/or response data to disk.
Args:
directory: Directory to save data to (default: "./output/")
+ save_request: Whether to save request data (default: True)
+ save_response: Whether to save response data (default: True)
"""
- if not self.responses:
+ if not self.responses and save_response:
raise RuntimeError(
"No responses to save. Send requests first using send_requests()"
)
save_dir = Path(directory)
- request_path = ensure_directory_exists(save_dir / "requests")
-
- # Determine file extension based on protocol
extension = "xml" if self.protocol == ApiProtocol.soap else "json"
- # Save requests
- if self.protocol == ApiProtocol.soap:
- request_data = [request.model_dump_xml() for request in self.requests]
- else:
- request_data = [
- request.model_dump(exclude_none=True) for request in self.requests
- ]
-
- save_data_to_directory(
- request_data,
- "request",
- self.sandbox_id,
- request_path,
- extension,
- )
- log.info(f"Saved request data at {request_path}/")
-
- # Save responses
- response_path = ensure_directory_exists(save_dir / "responses")
- save_data_to_directory(
- self.responses,
- "response",
- self.sandbox_id,
- response_path,
- extension,
- )
- log.info(f"Saved response data at {response_path}/")
+ if save_request:
+ request_path = ensure_directory_exists(save_dir / "requests")
+ if self.protocol == ApiProtocol.soap:
+ request_data = [request.model_dump_xml() for request in self.requests]
+ else:
+ request_data = [
+ request.model_dump(mode="json", exclude_none=True)
+ for request in self.requests
+ ]
+ save_data_to_directory(
+ request_data,
+ "request",
+ self.sandbox_id,
+ request_path,
+ extension,
+ )
+ log.info(f"Saved request data at {request_path}/")
+
+ if save_response:
+ response_path = ensure_directory_exists(save_dir / "responses")
+ save_data_to_directory(
+ self.responses,
+ "response",
+ self.sandbox_id,
+ response_path,
+ extension,
+ )
+ log.info(f"Saved response data at {response_path}/")
def get_status(self) -> Dict[str, Any]:
"""
diff --git a/mkdocs.yml b/mkdocs.yml
index 8692f0d3..00d9ebc0 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -18,6 +18,7 @@ nav:
- Multi-Source Data Integration: cookbook/multi_ehr_aggregation.md
- Automated Clinical Coding: cookbook/clinical_coding.md
- Discharge Summarizer: cookbook/discharge_summarizer.md
+ - ML Model Deployment: cookbook/ml_model_deployment.md
- Docs:
- Welcome: reference/index.md
- Gateway:
diff --git a/notebooks/fhir_ml_workflow.ipynb b/notebooks/fhir_ml_workflow.ipynb
new file mode 100644
index 00000000..5a73c1dd
--- /dev/null
+++ b/notebooks/fhir_ml_workflow.ipynb
@@ -0,0 +1,567 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from healthchain.sandbox.loaders import MimicOnFHIRLoader\n",
+ "from healthchain.io import Dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "MIMIC_DIR = \"../../datasets/mimic-iv-clinical-database-demo-on-fhir-2.1.0/\"\n",
+ "RESOURCES_TO_LOAD = [\"MimicObservationChartevents\", \"MimicObservationLabevents\", \"MimicPatient\"]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "INFO: 2025-11-27 18:55:49,156 [healthchain.sandbox.loaders.mimic]: Loaded 668862 resources from MimicObservationChartevents.ndjson.gz\n",
+ "INFO: 2025-11-27 18:55:54,360 [healthchain.sandbox.loaders.mimic]: Loaded 107727 resources from MimicObservationLabevents.ndjson.gz\n",
+ "INFO: 2025-11-27 18:55:54,366 [healthchain.sandbox.loaders.mimic]: Loaded 100 resources from MimicPatient.ndjson.gz\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Load MIMIC data as single bundle dict (fast, no validation)\n",
+ "loader = MimicOnFHIRLoader()\n",
+ "bundle = loader.load(\n",
+ " data_dir=MIMIC_DIR,\n",
+ " resource_types=RESOURCES_TO_LOAD,\n",
+ " as_dict=True\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "776689"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(bundle[\"entry\"])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Convert to DataFrame using schema\n",
+ "tabular = Dataset.from_fhir_bundle(\n",
+ " bundle, \n",
+ " schema=\"../healthchain/configs/features/sepsis_vitals.yaml\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'patient_ref': 'object',\n",
+ " 'heart_rate': 'float64',\n",
+ " 'temperature': 'float64',\n",
+ " 'respiratory_rate': 'float64',\n",
+ " 'wbc': 'float64',\n",
+ " 'lactate': 'float64',\n",
+ " 'creatinine': 'float64',\n",
+ " 'age': 'int64',\n",
+ " 'gender_encoded': 'int64'}"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "tabular.dtypes"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "100"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(tabular)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " patient_ref | \n",
+ " heart_rate | \n",
+ " temperature | \n",
+ " respiratory_rate | \n",
+ " wbc | \n",
+ " lactate | \n",
+ " creatinine | \n",
+ " age | \n",
+ " gender_encoded | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " Patient/0a8eebfd-a352-522e-89f0-1d4a13abdebc | \n",
+ " 96.500000 | \n",
+ " 98.966667 | \n",
+ " 20.700000 | \n",
+ " 5.815385 | \n",
+ " 31.0 | \n",
+ " 0.466667 | \n",
+ " 52 | \n",
+ " 0 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " Patient/0c2243d2-987b-5cbd-8eb1-170a80647693 | \n",
+ " 85.379310 | \n",
+ " 98.135294 | \n",
+ " 12.103448 | \n",
+ " 7.737500 | \n",
+ " 66.5 | \n",
+ " 0.594937 | \n",
+ " 57 | \n",
+ " 1 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " Patient/13df78e7-150e-5eb7-be5f-5f62b2baee87 | \n",
+ " 104.307692 | \n",
+ " 98.375000 | \n",
+ " 15.961538 | \n",
+ " 8.337500 | \n",
+ " NaN | \n",
+ " 0.966667 | \n",
+ " 66 | \n",
+ " 1 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " Patient/158f3a39-e3d7-5e7a-93aa-57af894aadd9 | \n",
+ " 99.739130 | \n",
+ " 98.390000 | \n",
+ " 18.358696 | \n",
+ " 11.509091 | \n",
+ " NaN | \n",
+ " 0.628571 | \n",
+ " 40 | \n",
+ " 0 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " Patient/1ab119a5-aac8-5002-9d2f-b8ff69623387 | \n",
+ " 93.402985 | \n",
+ " 98.824242 | \n",
+ " 21.753731 | \n",
+ " 15.578571 | \n",
+ " NaN | \n",
+ " 0.646667 | \n",
+ " 34 | \n",
+ " 1 | \n",
+ "
\n",
+ " \n",
+ " | 5 | \n",
+ " Patient/1bb918ba-e04e-5e7a-87ca-dbcbbb4c72c3 | \n",
+ " 78.181818 | \n",
+ " 98.725000 | \n",
+ " 16.961538 | \n",
+ " 22.906250 | \n",
+ " NaN | \n",
+ " 0.756667 | \n",
+ " 38 | \n",
+ " 0 | \n",
+ "
\n",
+ " \n",
+ " | 6 | \n",
+ " Patient/1cf9e585-806c-513b-80af-4ca565a28231 | \n",
+ " 104.666667 | \n",
+ " 98.810000 | \n",
+ " 19.388889 | \n",
+ " 12.520952 | \n",
+ " NaN | \n",
+ " 3.847321 | \n",
+ " 53 | \n",
+ " 1 | \n",
+ "
\n",
+ " \n",
+ " | 7 | \n",
+ " Patient/22a3e422-663a-561c-b305-a0c04bf42235 | \n",
+ " 69.050000 | \n",
+ " 98.800000 | \n",
+ " 16.900000 | \n",
+ " 10.754545 | \n",
+ " NaN | \n",
+ " 1.353846 | \n",
+ " 87 | \n",
+ " 1 | \n",
+ "
\n",
+ " \n",
+ " | 8 | \n",
+ " Patient/23069939-0c4c-517b-a3ec-baae0d4e3988 | \n",
+ " 78.694444 | \n",
+ " 98.325000 | \n",
+ " 16.055556 | \n",
+ " 9.383333 | \n",
+ " NaN | \n",
+ " 0.860000 | \n",
+ " 52 | \n",
+ " 1 | \n",
+ "
\n",
+ " \n",
+ " | 9 | \n",
+ " Patient/23f959c1-6ac2-562b-9cbe-c111f338e27b | \n",
+ " 87.184524 | \n",
+ " 98.827091 | \n",
+ " 17.251497 | \n",
+ " 14.954054 | \n",
+ " NaN | \n",
+ " 0.642105 | \n",
+ " 51 | \n",
+ " 1 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " patient_ref heart_rate temperature \\\n",
+ "0 Patient/0a8eebfd-a352-522e-89f0-1d4a13abdebc 96.500000 98.966667 \n",
+ "1 Patient/0c2243d2-987b-5cbd-8eb1-170a80647693 85.379310 98.135294 \n",
+ "2 Patient/13df78e7-150e-5eb7-be5f-5f62b2baee87 104.307692 98.375000 \n",
+ "3 Patient/158f3a39-e3d7-5e7a-93aa-57af894aadd9 99.739130 98.390000 \n",
+ "4 Patient/1ab119a5-aac8-5002-9d2f-b8ff69623387 93.402985 98.824242 \n",
+ "5 Patient/1bb918ba-e04e-5e7a-87ca-dbcbbb4c72c3 78.181818 98.725000 \n",
+ "6 Patient/1cf9e585-806c-513b-80af-4ca565a28231 104.666667 98.810000 \n",
+ "7 Patient/22a3e422-663a-561c-b305-a0c04bf42235 69.050000 98.800000 \n",
+ "8 Patient/23069939-0c4c-517b-a3ec-baae0d4e3988 78.694444 98.325000 \n",
+ "9 Patient/23f959c1-6ac2-562b-9cbe-c111f338e27b 87.184524 98.827091 \n",
+ "\n",
+ " respiratory_rate wbc lactate creatinine age gender_encoded \n",
+ "0 20.700000 5.815385 31.0 0.466667 52 0 \n",
+ "1 12.103448 7.737500 66.5 0.594937 57 1 \n",
+ "2 15.961538 8.337500 NaN 0.966667 66 1 \n",
+ "3 18.358696 11.509091 NaN 0.628571 40 0 \n",
+ "4 21.753731 15.578571 NaN 0.646667 34 1 \n",
+ "5 16.961538 22.906250 NaN 0.756667 38 0 \n",
+ "6 19.388889 12.520952 NaN 3.847321 53 1 \n",
+ "7 16.900000 10.754545 NaN 1.353846 87 1 \n",
+ "8 16.055556 9.383333 NaN 0.860000 52 1 \n",
+ "9 17.251497 14.954054 NaN 0.642105 51 1 "
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df = tabular.data\n",
+ "df.head(10)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "100"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(df)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import joblib\n",
+ "MODEL_PATH = '../cookbook/models/sepsis_model.pkl'\n",
+ "model_data = joblib.load(MODEL_PATH)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'model': XGBClassifier(base_score=None, booster=None, callbacks=None,\n",
+ " colsample_bylevel=None, colsample_bynode=None,\n",
+ " colsample_bytree=None, device=None, early_stopping_rounds=None,\n",
+ " enable_categorical=False, eval_metric='logloss',\n",
+ " feature_types=None, feature_weights=None, gamma=None,\n",
+ " grow_policy=None, importance_type=None,\n",
+ " interaction_constraints=None, learning_rate=None, max_bin=None,\n",
+ " max_cat_threshold=None, max_cat_to_onehot=None,\n",
+ " max_delta_step=None, max_depth=None, max_leaves=None,\n",
+ " min_child_weight=None, missing=nan, monotone_constraints=None,\n",
+ " multi_strategy=None, n_estimators=None, n_jobs=-1,\n",
+ " num_parallel_tree=None, ...),\n",
+ " 'scaler': StandardScaler(),\n",
+ " 'metadata': {'model_name': 'XGBoost',\n",
+ " 'training_date': '2025-11-22T13:52:14.144052',\n",
+ " 'feature_names': ['heart_rate',\n",
+ " 'temperature',\n",
+ " 'respiratory_rate',\n",
+ " 'wbc',\n",
+ " 'lactate',\n",
+ " 'creatinine',\n",
+ " 'age',\n",
+ " 'gender_encoded'],\n",
+ " 'metrics': {'accuracy': 0.8214285714285714,\n",
+ " 'precision': 0.5,\n",
+ " 'recall': 0.2,\n",
+ " 'f1': 0.2857142857142857,\n",
+ " 'auc': 0.7391304347826086,\n",
+ " 'optimal_threshold': 0.19611828,\n",
+ " 'optimal_f1': 0.5454545454049586,\n",
+ " 'optimal_precision': 0.5,\n",
+ " 'optimal_recall': 0.6},\n",
+ " 'itemid_mappings': {'chartevents': {'heart_rate': 220050,\n",
+ " 'temperature_f': 223761,\n",
+ " 'temperature_c': 223762,\n",
+ " 'respiratory_rate': 220210},\n",
+ " 'labevents': {'wbc': [51300, 51301],\n",
+ " 'lactate': 50813,\n",
+ " 'creatinine': 50912}},\n",
+ " 'sepsis_icd_codes': {'icd10': ['A41.9',\n",
+ " 'A40',\n",
+ " 'A41',\n",
+ " 'R65.20',\n",
+ " 'R65.21',\n",
+ " 'R65.1',\n",
+ " 'A41.0',\n",
+ " 'A41.1',\n",
+ " 'A41.2',\n",
+ " 'A41.3',\n",
+ " 'A41.4',\n",
+ " 'A41.5',\n",
+ " 'A41.50',\n",
+ " 'A41.51',\n",
+ " 'A41.52',\n",
+ " 'A41.53',\n",
+ " 'A41.59',\n",
+ " 'A41.8',\n",
+ " 'A41.81',\n",
+ " 'A41.89'],\n",
+ " 'icd9': ['038', '99591', '99592', '78552']}}}"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "model_data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model = model_data[\"model\"]\n",
+ "patient_features = df[model_data[\"metadata\"][\"feature_names\"]]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# ML inference\n",
+ "probabilities = model.predict_proba(patient_features)[:, 1]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "threshold = model_data[\"metadata\"][\"metrics\"][\"optimal_threshold\"]\n",
+ "predictions = (probabilities >= threshold).astype(int)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Convert back to FHIR\n",
+ "risk_assessments = tabular.to_risk_assessment(\n",
+ " outcome_code=\"A41.9\",\n",
+ " outcome_display=\"Sepsis\",\n",
+ " model_name=\"XGBoost\"\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "100"
+ ]
+ },
+ "execution_count": 16,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "len(risk_assessments)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "{'resourceType': 'RiskAssessment',\n",
+ " 'id': 'hc-71012a5d-cf7f-436d-864b-327efe28b483',\n",
+ " 'status': 'final',\n",
+ " 'method': {'coding': [{'system': 'https://healthchain.github.io/ml-models',\n",
+ " 'code': 'XGBoost',\n",
+ " 'display': 'XGBoost'}]},\n",
+ " 'subject': {'reference': 'Patient/1bb918ba-e04e-5e7a-87ca-dbcbbb4c72c3'},\n",
+ " 'occurrenceDateTime': datetime.datetime(2025, 11, 27, 18, 56, 51, tzinfo=TzInfo(UTC)),\n",
+ " 'prediction': [{'outcome': {'coding': [{'system': 'http://hl7.org/fhir/sid/icd-10',\n",
+ " 'code': 'A41.9',\n",
+ " 'display': 'Sepsis'}]},\n",
+ " 'probabilityDecimal': 0.07619287073612213,\n",
+ " 'qualitativeRisk': {'coding': [{'system': 'http://terminology.hl7.org/CodeSystem/risk-probability',\n",
+ " 'code': 'low',\n",
+ " 'display': 'Low'}]}}],\n",
+ " 'note': [{'text': 'ML prediction: Negative (probability: 7.62%, risk: low)'}]}"
+ ]
+ },
+ "execution_count": 17,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "risk_assessments[5].model_dump()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "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.11.0"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/output/README.md b/output/README.md
deleted file mode 100644
index 2b90777e..00000000
--- a/output/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Output Directory
-
-This is where the requests and responses generated by sandbox runs will be saved.
diff --git a/scripts/check_epic_connection.py b/scripts/check_epic_connection.py
new file mode 100644
index 00000000..e55ad023
--- /dev/null
+++ b/scripts/check_epic_connection.py
@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""
+Quick Epic FHIR connection test.
+
+Run: python scripts/check_epic_connection.py
+"""
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+def main():
+ print("=" * 50)
+ print("Epic FHIR Connection Test")
+ print("=" * 50)
+
+ # 1. Load config
+ print("\n1. Loading config from environment...")
+ try:
+ from healthchain.gateway.clients.fhir.base import FHIRAuthConfig
+
+ config = FHIRAuthConfig.from_env("EPIC")
+ print(f" ✓ client_id: {config.client_id[:8]}...")
+ print(f" ✓ token_url: {config.token_url}")
+ print(f" ✓ base_url: {config.base_url}")
+ print(f" ✓ use_jwt_assertion: {config.use_jwt_assertion}")
+ except Exception as e:
+ print(f" ✗ Failed to load config: {e}")
+ return False
+
+ # 2. Test JWT creation
+ print("\n2. Creating JWT assertion...")
+ try:
+ oauth_config = config.to_oauth2_config()
+ from healthchain.gateway.clients.auth import OAuth2TokenManager
+
+ manager = OAuth2TokenManager(oauth_config)
+ jwt = manager._create_jwt_assertion()
+ print(f" ✓ JWT created ({len(jwt)} chars)")
+ except Exception as e:
+ print(f" ✗ JWT creation failed: {e}")
+ return False
+
+ # 3. Get access token
+ print("\n3. Requesting access token from Epic...")
+ try:
+ token = manager.get_access_token()
+ print(f" ✓ Token received: {token[:20]}...")
+ except Exception as e:
+ print(f" ✗ Token request failed: {e}")
+ print("\n Possible causes:")
+ print(" - App changes still propagating (wait 15-30 min)")
+ print(" - Public key not registered in Epic App Orchard")
+ print(" - App not in 'Ready for Sandbox' state")
+ return False
+
+ # 4. Test FHIR endpoint
+ print("\n4. Testing FHIR endpoint (CapabilityStatement)...")
+ try:
+ from healthchain.gateway.clients.fhir.sync.client import FHIRClient
+
+ client = FHIRClient(config)
+ caps = client.capabilities()
+ print(f" ✓ FHIR server: {caps.software.name if caps.software else 'Unknown'}")
+ print(f" ✓ FHIR version: {caps.fhirVersion}")
+ except Exception as e:
+ print(f" ✗ FHIR request failed: {e}")
+ return False
+
+ # 5. Test patient read (optional)
+ print("\n5. Testing Patient read...")
+ test_patient_id = "e0w0LEDCYtfckT6N.CkJKCw3" # Epic sandbox patient
+ try:
+ from fhir.resources.patient import Patient
+
+ patient = client.read(Patient, test_patient_id)
+ name = patient.name[0] if patient.name else None
+ print(
+ f" ✓ Patient: {name.given[0] if name and name.given else '?'} {name.family if name else '?'}"
+ )
+ except Exception as e:
+ print(f" ⚠ Patient read failed: {e}")
+ print(" (This may be a permissions issue, not a connection issue)")
+
+ print("\n" + "=" * 50)
+ print("✓ Epic connection working!")
+ print("=" * 50)
+ return True
+
+
+if __name__ == "__main__":
+ import sys
+
+ success = main()
+ sys.exit(0 if success else 1)
diff --git a/scripts/extract_mimic_demo_patients.py b/scripts/extract_mimic_demo_patients.py
new file mode 100755
index 00000000..8e68e86e
--- /dev/null
+++ b/scripts/extract_mimic_demo_patients.py
@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+"""
+Extract Demo Patients from MIMIC-on-FHIR
+
+Extracts patient data for sepsis prediction demos. Creates small files with
+only the observations needed for the model.
+
+Usage:
+ # For CDS Hooks demo (prefetch format)
+ python scripts/extract_mimic_demo_patients.py --minimal
+
+ # For FHIR batch demo (upload to Medplum)
+ python scripts/extract_mimic_demo_patients.py --minimal --upload
+
+Output formats:
+ Default (prefetch for CDS Hooks):
+ {"patient": {...}, "heart_rate": {"entry": [...]}, ...}
+
+ --bundle (for FHIR server upload):
+ {"resourceType": "Bundle", "type": "transaction", "entry": [...]}
+
+Requires:
+ - MIMIC_FHIR_PATH env var (or --mimic flag)
+ - MEDPLUM_* env vars (if using --upload)
+"""
+
+import argparse
+import json
+import os
+import uuid
+from pathlib import Path
+
+import joblib
+import yaml
+
+from healthchain.io import Dataset
+from healthchain.pipeline import Pipeline
+from healthchain.sandbox.loaders import MimicOnFHIRLoader
+
+try:
+ from dotenv import load_dotenv
+
+ load_dotenv()
+except ImportError:
+ pass
+
+# =============================================================================
+# CONFIGURATION
+# =============================================================================
+
+DEFAULT_MODEL_PATH = "cookbook/models/sepsis_model.pkl"
+DEFAULT_SCHEMA_PATH = "healthchain/configs/features/sepsis_vitals.yaml"
+DEFAULT_OUTPUT_DIR = Path("cookbook/data/mimic_demo_patients")
+
+
+# =============================================================================
+# HELPER FUNCTIONS
+# =============================================================================
+
+
+def load_observation_codes(schema_path: str) -> dict:
+ """Extract observation codes from feature schema."""
+ with open(schema_path) as f:
+ schema = yaml.safe_load(f)
+ return {
+ config["code"]: name
+ for name, config in schema["features"].items()
+ if config.get("fhir_resource") == "Observation"
+ }
+
+
+def create_pipeline(model, feature_names) -> Pipeline[Dataset]:
+ """Build prediction pipeline for risk stratification."""
+ pipeline = Pipeline[Dataset]()
+
+ @pipeline.add_node
+ def impute_missing(dataset: Dataset) -> Dataset:
+ dataset.data = dataset.data.fillna(dataset.data.median(numeric_only=True))
+ return dataset
+
+ @pipeline.add_node
+ def run_inference(dataset: Dataset) -> Dataset:
+ features = dataset.data[feature_names]
+ dataset.metadata["probabilities"] = model.predict_proba(features)[:, 1]
+ return dataset
+
+ return pipeline
+
+
+def get_observation_code(resource: dict) -> str:
+ """Extract MIMIC code from Observation."""
+ for coding in resource.get("code", {}).get("coding", []):
+ if "mimic" in coding.get("system", ""):
+ return coding.get("code", "")
+ return ""
+
+
+# =============================================================================
+# EXTRACTION FUNCTIONS
+# =============================================================================
+
+
+def extract_patient_prefetch(
+ bundle: dict, patient_ref: str, obs_codes: dict, minimal: bool = False
+) -> dict:
+ """Extract keyed prefetch for a patient (CDS Hooks format)."""
+ patient_id = patient_ref.split("/")[-1]
+ prefetch = {}
+ feature_obs = {name: [] for name in obs_codes.values()}
+
+ for entry in bundle["entry"]:
+ resource = entry.get("resource", {})
+ rtype = resource.get("resourceType", "")
+
+ if rtype == "Patient" and resource.get("id") == patient_id:
+ prefetch["patient"] = resource
+ elif rtype == "Observation":
+ ref = resource.get("subject", {}).get("reference", "")
+ if ref.endswith(patient_id):
+ code = get_observation_code(resource)
+ if code in obs_codes:
+ feature_obs[obs_codes[code]].append(entry)
+
+ for name, entries in feature_obs.items():
+ if entries:
+ if minimal:
+ entries = entries[-1:] # Keep only latest
+ prefetch[name] = {
+ "resourceType": "Bundle",
+ "type": "searchset",
+ "entry": entries,
+ }
+
+ return prefetch
+
+
+def prefetch_to_bundle(prefetch: dict) -> dict:
+ """Convert prefetch to FHIR transaction Bundle (for server upload)."""
+ entries = []
+ # Use urn:uuid references so Medplum properly links Observations to Patient.
+ patient_uuid = f"urn:uuid:{uuid.uuid4()}"
+
+ # Patient
+ if "patient" in prefetch:
+ entries.append(
+ {
+ "fullUrl": patient_uuid,
+ "resource": prefetch["patient"].copy(),
+ "request": {"method": "POST", "url": "Patient"},
+ }
+ )
+
+ # Observations (with updated subject reference)
+ for key, value in prefetch.items():
+ if key == "patient" or not isinstance(value, dict):
+ continue
+ for entry in value.get("entry", []):
+ resource = entry.get("resource", {})
+ if resource.get("resourceType") == "Observation":
+ obs = resource.copy()
+ obs["subject"] = {"reference": patient_uuid}
+ entries.append(
+ {
+ "fullUrl": f"urn:uuid:{uuid.uuid4()}",
+ "resource": obs,
+ "request": {"method": "POST", "url": "Observation"},
+ }
+ )
+
+ return {"resourceType": "Bundle", "type": "transaction", "entry": entries}
+
+
+def upload_bundle(gateway, bundle_data: dict) -> str:
+ """Upload bundle to Medplum, return server-assigned Patient ID."""
+ from fhir.resources.bundle import Bundle as FHIRBundle
+
+ response = gateway.transaction(FHIRBundle(**bundle_data), source="medplum")
+
+ # Extract Patient ID from response
+ if response.entry:
+ for entry in response.entry:
+ if entry.response and entry.response.location:
+ loc = entry.response.location
+ if "Patient/" in loc:
+ return loc.split("Patient/")[1].split("/")[0]
+ return None
+
+
+# =============================================================================
+# MAIN
+# =============================================================================
+
+
+def main():
+ parser = argparse.ArgumentParser(
+ description="Extract demo patients from MIMIC-on-FHIR"
+ )
+ parser.add_argument("--mimic", type=str, help="Path to MIMIC-on-FHIR dataset")
+ parser.add_argument(
+ "--model", type=str, default=DEFAULT_MODEL_PATH, help="Model pickle path"
+ )
+ parser.add_argument(
+ "--schema", type=str, default=DEFAULT_SCHEMA_PATH, help="Feature schema YAML"
+ )
+ parser.add_argument(
+ "--minimal", action="store_true", help="Keep only 1 obs per feature (~12KB)"
+ )
+ parser.add_argument("--bundle", action="store_true", help="Output as FHIR Bundle")
+ parser.add_argument("--upload", action="store_true", help="Upload to Medplum")
+ parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT_DIR)
+ parser.add_argument("--seed", type=int, default=42)
+ parser.add_argument("--num-patients-per-risk", type=int, default=1)
+ args = parser.parse_args()
+
+ mimic_dir = args.mimic or os.getenv("MIMIC_FHIR_PATH")
+ if not mimic_dir:
+ print("Error: Set MIMIC_FHIR_PATH or use --mimic")
+ return
+
+ # --upload implies --bundle
+ if args.upload:
+ args.bundle = True
+
+ # Set up FHIRGateway for upload
+ gateway = None
+ if args.upload:
+ from healthchain.gateway import FHIRGateway
+ from healthchain.gateway.clients.fhir.base import FHIRAuthConfig
+
+ try:
+ config = FHIRAuthConfig.from_env("MEDPLUM")
+ gateway = FHIRGateway()
+ gateway.add_source("medplum", config.to_connection_string())
+ print("✓ Medplum configured")
+ except Exception as e:
+ print(f"✗ Medplum failed: {e}")
+ return
+
+ print("=" * 60)
+ print("MIMIC Demo Patient Extraction" + (" (MINIMAL)" if args.minimal else ""))
+ print("=" * 60)
+
+ # Load schema and model
+ obs_codes = load_observation_codes(args.schema)
+ print(f"Features: {list(obs_codes.values())}")
+
+ model_data = joblib.load(args.model)
+ model = model_data["model"]
+ feature_names = model_data["metadata"]["feature_names"]
+
+ # Load MIMIC data
+ print("\nLoading MIMIC-on-FHIR...")
+ loader = MimicOnFHIRLoader()
+ bundle = loader.load(
+ data_dir=mimic_dir,
+ resource_types=[
+ "MimicObservationChartevents",
+ "MimicObservationLabevents",
+ "MimicPatient",
+ ],
+ as_dict=True,
+ )
+ print(f"Loaded {len(bundle['entry']):,} resources")
+
+ # Run predictions
+ print("\nExtracting features...")
+ dataset = Dataset.from_fhir_bundle(bundle, schema=args.schema)
+ result = create_pipeline(model, feature_names)(dataset)
+
+ df = result.data.copy()
+ df["probability"] = result.metadata["probabilities"]
+ df["risk"] = df["probability"].apply(
+ lambda p: "high" if p > 0.7 else "moderate" if p > 0.4 else "low"
+ )
+
+ print(f"\nRisk distribution ({len(df)} patients):")
+ print(df["risk"].value_counts().to_string())
+
+ # Extract patients
+ args.output.mkdir(parents=True, exist_ok=True)
+ print(f"\nExtracting to {args.output}/")
+
+ uploaded_ids = [] # Track server-assigned IDs for copy-paste output
+
+ for risk_level in ["high", "moderate", "low"]:
+ risk_df = df[df["risk"] == risk_level]
+ if len(risk_df) == 0:
+ continue
+
+ risk_df = risk_df.sample(
+ n=min(args.num_patients_per_risk, len(risk_df)), random_state=args.seed
+ )
+
+ for i, (_, patient) in enumerate(risk_df.iterrows()):
+ label = (
+ f"{risk_level}_risk"
+ if args.num_patients_per_risk == 1
+ else f"{risk_level}_risk_{i+1}"
+ )
+ prefetch = extract_patient_prefetch(
+ bundle, patient["patient_ref"], obs_codes, args.minimal
+ )
+
+ # Output format
+ if args.bundle:
+ output_data = prefetch_to_bundle(prefetch)
+ suffix = "_bundle.json"
+ else:
+ output_data = prefetch
+ suffix = "_patient.json"
+
+ # Save file
+ with open(args.output / f"{label}{suffix}", "w") as f:
+ json.dump(output_data, f, indent=2, default=str)
+
+ obs_count = sum(
+ len(v.get("entry", [])) for k, v in prefetch.items() if k != "patient"
+ )
+ patient_id = patient["patient_ref"].split("/")[-1]
+
+ # Upload if requested
+ status = ""
+ if args.upload and gateway:
+ server_id = upload_bundle(gateway, output_data)
+ if server_id:
+ uploaded_ids.append((server_id, risk_level))
+ status = f" ✓ uploaded (ID: {server_id})"
+ else:
+ status = " ✓ uploaded"
+
+ print(
+ f" {label}: {patient_id} ({patient['probability']:.1%}, {obs_count} obs){status}"
+ )
+
+ # Print next steps
+ print("\n" + "=" * 60)
+ if args.upload:
+ print("✓ Uploaded to Medplum!")
+ if uploaded_ids:
+ print("\nCopy this into sepsis_fhir_batch.py:\n")
+ print("DEMO_PATIENT_IDS = [")
+ for server_id, risk in uploaded_ids:
+ print(f' "{server_id}", # {risk} risk')
+ print("]")
+ elif args.bundle:
+ print("Re-run with --upload to upload to Medplum")
+ else:
+ print("CDS: client.load_from_path('cookbook/data/mimic_demo_patients/')")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/cookbook/sepsis_prediction_inference.py b/scripts/sepsis_prediction_inference.py
similarity index 100%
rename from cookbook/sepsis_prediction_inference.py
rename to scripts/sepsis_prediction_inference.py
diff --git a/cookbook/sepsis_prediction_training.py b/scripts/sepsis_prediction_training.py
similarity index 99%
rename from cookbook/sepsis_prediction_training.py
rename to scripts/sepsis_prediction_training.py
index a0ea85ce..16d630de 100644
--- a/cookbook/sepsis_prediction_training.py
+++ b/scripts/sepsis_prediction_training.py
@@ -12,6 +12,7 @@
- python sepsis_prediction_training.py
"""
+import os
import pandas as pd
import numpy as np
from pathlib import Path
@@ -898,8 +899,10 @@ def save_model(
def main():
"""Main training pipeline."""
- # Data directory
- data_dir = "../datasets/mimic-iv-clinical-database-demo-2.2"
+ # Data directory (set via MIMIC_CSV_PATH or use default)
+ data_dir = os.getenv(
+ "MIMIC_CSV_PATH", "../datasets/mimic-iv-clinical-database-demo-2.2"
+ )
# Output path (relative to script location)
script_dir = Path(__file__).parent
diff --git a/tests/fhir/test_converters.py b/tests/fhir/test_converters.py
index 40e06725..aa16c20a 100644
--- a/tests/fhir/test_converters.py
+++ b/tests/fhir/test_converters.py
@@ -23,6 +23,7 @@
create_value_quantity_observation,
create_condition,
create_medication_statement,
+ prefetch_to_bundle,
)
@@ -523,3 +524,42 @@ def test_bundle_to_dataframe_skips_unsupported_resources_gracefully():
# Should not raise error, just skip unsupported types
df = bundle_to_dataframe(bundle, config=config)
assert len(df) == 1
+
+
+def test_prefetch_to_bundle_flattens_cds_prefetch():
+ """prefetch_to_bundle converts CDS Hooks prefetch to collection bundle."""
+ prefetch = {
+ "patient": {"resourceType": "Patient", "id": "123", "gender": "male"},
+ "heart_rate": {
+ "resourceType": "Bundle",
+ "type": "searchset",
+ "entry": [
+ {
+ "resource": {
+ "resourceType": "Observation",
+ "code": {"coding": [{"code": "8867-4"}]},
+ "valueQuantity": {"value": 85.0},
+ }
+ }
+ ],
+ },
+ }
+
+ bundle = prefetch_to_bundle(prefetch)
+
+ assert bundle["type"] == "collection"
+ assert len(bundle["entry"]) == 2
+ # Patient should be wrapped in resource
+ patient_entry = next(
+ e
+ for e in bundle["entry"]
+ if e.get("resource", {}).get("resourceType") == "Patient"
+ )
+ assert patient_entry["resource"]["id"] == "123"
+
+
+def test_prefetch_to_bundle_handles_empty_prefetch():
+ """prefetch_to_bundle handles empty prefetch gracefully."""
+ bundle = prefetch_to_bundle({})
+ assert bundle["type"] == "collection"
+ assert bundle["entry"] == []
diff --git a/tests/io/test_dataset.py b/tests/io/test_dataset.py
index be2e25f1..272f26b2 100644
--- a/tests/io/test_dataset.py
+++ b/tests/io/test_dataset.py
@@ -128,9 +128,9 @@ def test_dataset_to_risk_assessment_creates_resources_with_metadata(sample_datas
probabilities = np.array([0.15, 0.85])
# Test with model metadata
+ sample_dataset.metadata["predictions"] = predictions
+ sample_dataset.metadata["probabilities"] = probabilities
risks = sample_dataset.to_risk_assessment(
- predictions,
- probabilities,
outcome_code="A41.9",
outcome_display="Sepsis",
model_name="RandomForest",
@@ -183,10 +183,10 @@ def test_dataset_to_risk_assessment_categorizes_risk_levels(
}
)
dataset = Dataset(data)
+ dataset.metadata["predictions"] = np.array(predictions)
+ dataset.metadata["probabilities"] = np.array(probabilities)
risks = dataset.to_risk_assessment(
- np.array(predictions),
- np.array(probabilities),
outcome_code="A41.9",
outcome_display="Sepsis",
)
@@ -224,11 +224,11 @@ def test_dataset_to_risk_assessment_validation_errors(
"""Dataset.to_risk_assessment validates required columns and array lengths."""
data = pd.DataFrame(data_dict)
dataset = Dataset(data)
+ dataset.metadata["predictions"] = np.array(predictions)
+ dataset.metadata["probabilities"] = np.array(probabilities)
with pytest.raises(ValueError, match=expected_error):
dataset.to_risk_assessment(
- np.array(predictions),
- np.array(probabilities),
outcome_code="A41.9",
outcome_display="Sepsis",
)
@@ -284,11 +284,8 @@ def test_dataset_to_risk_assessment_validates_probability_length():
"""Dataset.to_risk_assessment validates probabilities array length."""
data = pd.DataFrame({"patient_ref": ["Patient/1", "Patient/2"], "value": [1, 2]})
dataset = Dataset(data)
-
- predictions = np.array([0, 1])
- probabilities = np.array([0.15]) # Wrong length
+ dataset.metadata["predictions"] = np.array([0, 1])
+ dataset.metadata["probabilities"] = np.array([0.15]) # Wrong length
with pytest.raises(ValueError, match="Probabilities length .* must match"):
- dataset.to_risk_assessment(
- predictions, probabilities, outcome_code="A41.9", outcome_display="Sepsis"
- )
+ dataset.to_risk_assessment(outcome_code="A41.9", outcome_display="Sepsis")
-