| """Load aligned RealICU inputs and reference labels without the experiment code.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import math |
| from collections.abc import Collection |
| from pathlib import Path |
| from typing import Any |
|
|
| import pandas as pd |
|
|
|
|
| EVENT_COLUMNS = [ |
| "time", |
| "code", |
| "code_specifics", |
| "numeric_value", |
| "text_value", |
| "source_event_index", |
| "icu_event_index", |
| ] |
|
|
|
|
| class RealICULoader: |
| """Read one stay once, then select any of its published label windows.""" |
|
|
| def __init__(self, root: str | Path, label_set: str, stay_id: str) -> None: |
| if label_set not in {"gold", "scale"}: |
| raise ValueError("label_set must be 'gold' or 'scale'") |
|
|
| root = Path(root) |
| stays = pd.read_parquet( |
| root / "trajectories/icu_stay.parquet", |
| filters=[("stay_id", "==", stay_id)], |
| columns=["stay_id", "enter_time", "leave_time"], |
| ) |
| if len(stays) != 1: |
| raise ValueError(f"Expected one ICU stay for {stay_id}, found {len(stays)}") |
|
|
| with (root / label_set / "labels" / f"{stay_id}.json").open(encoding="utf-8") as handle: |
| payload = json.load(handle) |
| if payload["stay_id"] != stay_id: |
| raise ValueError(f"Label stay_id does not match {stay_id}") |
|
|
| self._windows = {window["window_index"]: window for window in payload["window_outputs"]} |
| if not self._windows or len(self._windows) != len(payload["window_outputs"]): |
| raise ValueError(f"Empty or duplicate label windows for {stay_id}") |
|
|
| self.stay_id = stay_id |
| self.enter_time = pd.Timestamp(stays.iloc[0]["enter_time"]) |
| self.leave_time = pd.Timestamp(stays.iloc[0]["leave_time"]) |
| self.window_indices = tuple(sorted(self._windows)) |
| self._events = pd.read_parquet( |
| root / "trajectories/events.parquet", |
| filters=[("stay_id", "==", stay_id)], |
| columns=EVENT_COLUMNS, |
| ).sort_values(["time", "source_event_index"], kind="stable").reset_index(drop=True) |
|
|
| @staticmethod |
| def _history_start(anchor: pd.Timestamp, hours: float | None) -> pd.Timestamp | None: |
| if hours is None: |
| return None |
| if not math.isfinite(hours) or hours < 0: |
| raise ValueError("History hours must be finite and nonnegative, or None for all available history") |
| return anchor - pd.Timedelta(hours=hours) |
|
|
| def _slice_events( |
| self, |
| start: pd.Timestamp | None, |
| end: pd.Timestamp, |
| excluded_event_codes: Collection[str], |
| ) -> pd.DataFrame: |
| times = self._events["time"] |
| left = 0 if start is None else times.searchsorted(start, side="left") |
| right = times.searchsorted(end, side="left") |
| events = self._events.iloc[left:right] |
| return events.loc[~events["code"].isin(excluded_event_codes)].copy().reset_index(drop=True) |
|
|
| def load_window( |
| self, |
| window_index: int, |
| *, |
| icu_history_hours: float | None, |
| pre_icu_history_hours: float | None, |
| excluded_event_codes: Collection[str], |
| ) -> dict[str, Any]: |
| """Return input event tables and labels; None selects all history, zero selects none.""" |
| window = self._windows[window_index] |
| metadata = window["window_metadata"] |
| start = pd.Timestamp(metadata["window_start_time"]) |
| end = pd.Timestamp(metadata["window_end_time"]) |
| if not self.enter_time <= start < end <= self.leave_time: |
| raise ValueError(f"Window {window_index} lies outside ICU stay {self.stay_id}") |
|
|
| history_start = self._history_start(start, icu_history_hours) |
| if history_start is None or history_start < self.enter_time: |
| history_start = self.enter_time |
| pre_icu_start = self._history_start(self.enter_time, pre_icu_history_hours) |
|
|
| return { |
| "input": { |
| "sample_id": window["sample_id"], |
| "stay_id": self.stay_id, |
| "window_start_time": start, |
| "window_end_time": end, |
| "pre_icu_events": self._slice_events(pre_icu_start, self.enter_time, excluded_event_codes), |
| "history_events": self._slice_events(history_start, start, excluded_event_codes), |
| "current_events": self._slice_events(start, end, excluded_event_codes), |
| }, |
| "labels": { |
| "reference_labels": window["reference_labels"], |
| "label_availability": window["label_availability"], |
| }, |
| } |
|
|
|
|
| def _parse_history_hours(value: str) -> float | None: |
| if value == "all": |
| return None |
| try: |
| hours = float(value) |
| except ValueError as error: |
| raise argparse.ArgumentTypeError("Use 'all' or a nonnegative number of hours") from error |
| if not math.isfinite(hours) or hours < 0: |
| raise argparse.ArgumentTypeError("Use 'all' or a finite, nonnegative number of hours") |
| return hours |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--root", type=Path, required=True) |
| parser.add_argument("--label-set", choices=["gold", "scale"], required=True) |
| parser.add_argument("--stay-id", required=True) |
| parser.add_argument("--window-index", type=int, required=True) |
| parser.add_argument("--icu-history-hours", type=_parse_history_hours, required=True) |
| parser.add_argument("--pre-icu-history-hours", type=_parse_history_hours, required=True) |
| parser.add_argument("--excluded-event-codes", nargs="*", required=True) |
| args = parser.parse_args() |
|
|
| loader = RealICULoader(args.root, args.label_set, args.stay_id) |
| sample = loader.load_window( |
| args.window_index, |
| icu_history_hours=args.icu_history_hours, |
| pre_icu_history_hours=args.pre_icu_history_hours, |
| excluded_event_codes=args.excluded_event_codes, |
| ) |
| model_input = sample["input"] |
| print(json.dumps({ |
| "sample_id": model_input["sample_id"], |
| "window_start_time": model_input["window_start_time"].isoformat(), |
| "window_end_time": model_input["window_end_time"].isoformat(), |
| "event_counts": { |
| key: len(model_input[key]) |
| for key in ("pre_icu_events", "history_events", "current_events") |
| }, |
| "label_availability": sample["labels"]["label_availability"], |
| }, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
