run_inference.py

"""

Standalone Inference Script — Improved ICH Screening (2.5D, 5-fold Ensemble)

=============================================================================

Reads raw DICOM CT brain slices, reproduces improved preprocessing from the

improvement notebooks, runs 5-fold EfficientNet-B4 ensemble inference, applies

saved calibration, and generates:

  • Per-image JSON reports (fixed schema)

  • Slice-level CSV summary

  • Patient-level CSV summary



No command-line arguments — all paths are configured in the CONFIG section.



Requirements:

  pip install torch timm pydicom opencv-python-headless numpy pandas scikit-learn



Usage:

  python run_inference.py

"""

import datetime
import json
import pickle
import warnings
from pathlib import Path
from typing import Dict, List, Optional, Tuple

import cv2
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import timm

# Try importing pydicom — needed for DICOM input mode
has_pydicom = False
try:
    import pydicom
    import pydicom.multival

    # Some anonymized datasets contain non-standard UID strings like "ID_xxx".
    # Ignore only this known noisy warning from pydicom.
    warnings.filterwarnings(
        "ignore",
        message=r"Invalid value for VR UI:",
        category=UserWarning,
        module=r"pydicom\.valuerep",
    )
    has_pydicom = True
except ImportError:
    pass

# ══════════════════════════════════════════════════════════════════════════
#  CONFIG — edit these paths before running
# ══════════════════════════════════════════════════════════════════════════

SCRIPT_DIR = Path(__file__).resolve().parent

# Model artifacts (required)
FOLD_MODEL_PATHS = [SCRIPT_DIR / f"best_model_fold{i}.pth" for i in range(5)]
CALIB_PARAMS_PATH = SCRIPT_DIR / "calibration_params.json"
ISOTONIC_MODELS_PATH = SCRIPT_DIR / "isotonic_models.pkl"
NORM_STATS_PATH = SCRIPT_DIR / "normalization_stats.json"

# Input — folder containing .dcm files
DICOM_INPUT_DIR = Path(r"D:\major8thsem\stage_2_test")

# Optional labels (only for quick validation against known RSNA IDs)
MANIFEST_PATH = SCRIPT_DIR / "manifest.csv"

# Output
OUTPUT_DIR = SCRIPT_DIR / "outputs"

# Architecture constants (must match training notebooks)
BACKBONE = "tf_efficientnet_b4"
IMG_SIZE = 380
IN_CHANNELS = 9
N_CLASSES = 6
DROPOUT = 0.4
DROP_PATH = 0.2

# Output / triage behavior
PATIENT_AGG_METHOD = "topk_mean"  # one of: max, mean, noisy_or, topk_mean
PATIENT_TOPK = 3
DECISION_THRESHOLD = None  # None -> use threshold_at_spec90 from calibration JSON
FOLD_SELECTION = "ensemble"  # "ensemble" or an integer fold id: 0..4
GENERATE_HEATMAPS = True

WINDOWS = [
    (40, 80),  # brain
    (75, 215),  # subdural
    (40, 380),  # soft tissue / bone
]

SUBTYPES = [
    "any",
    "epidural",
    "intraparenchymal",
    "intraventricular",
    "subarachnoid",
    "subdural",
]

OUTCOME_POSITIVE = "Hemorrhage indicator detected"
OUTCOME_NEGATIVE = "No hemorrhage indicator detected"

BAND_LABELS = {
    "HIGH": "High confidence",
    "MEDIUM": "Moderate confidence",
    "LOW": "Low confidence",
}

TRIAGE_ACTIONS = {
    ("POSITIVE", "HIGH"): "Urgent radiologist review recommended",
    ("POSITIVE", "MEDIUM"): "Prioritised radiologist review recommended",
    ("POSITIVE", "LOW"): "Radiologist review recommended — low confidence",
    ("NEGATIVE", "HIGH"): "Standard workflow — no urgent action",
    ("NEGATIVE", "MEDIUM"): "Standard workflow — manual review if clinically indicated",
    ("NEGATIVE", "LOW"): "Manual review recommended — model uncertainty high",
}

DISCLAIMER = (
    "This report is produced by an AI-assisted screening tool and does NOT "
    "constitute a medical diagnosis. All screening findings must be reviewed "
    "and confirmed by a qualified, licensed medical professional before any "
    "clinical decision is made. The system is intended solely as a "
    "decision-support aid in a screening workflow and is not cleared for "
    "standalone diagnostic use."
)


# ══════════════════════════════════════════════════════════════════════════
#  DICOM + PREPROCESSING
# ══════════════════════════════════════════════════════════════════════════


def _to_scalar(val) -> float:
    if has_pydicom and isinstance(val, (list, pydicom.multival.MultiValue)):
        return float(val[0])
    return float(val)


def apply_window(img_hu: np.ndarray, wc: float, ww: float) -> np.ndarray:
    lo = wc - ww / 2
    hi = wc + ww / 2
    return np.clip((img_hu - lo) / (hi - lo), 0.0, 1.0)


def load_single_dicom_3ch(dcm_path: Path, size: int = IMG_SIZE) -> np.ndarray:
    dcm = pydicom.dcmread(str(dcm_path))
    img = dcm.pixel_array.astype(np.float32)

    slope = _to_scalar(getattr(dcm, "RescaleSlope", 1))
    inter = _to_scalar(getattr(dcm, "RescaleIntercept", 0))
    img = img * slope + inter

    channels = []
    for wc, ww in WINDOWS:
        ch = apply_window(img, wc, ww)
        ch = cv2.resize(ch, (size, size), interpolation=cv2.INTER_AREA)
        channels.append(ch)

    return np.stack(channels, axis=-1).astype(np.float32)  # (H, W, 3) in [0,1]


def build_adjacency(dicom_dir: Path) -> pd.DataFrame:
    records: List[dict] = []
    for dcm_path in sorted(dicom_dir.glob("*.dcm")):
        image_id = dcm_path.stem
        try:
            dcm = pydicom.dcmread(str(dcm_path), stop_before_pixels=True)
            patient_id = str(getattr(dcm, "PatientID", "UNKNOWN"))
            series_uid = str(getattr(dcm, "SeriesInstanceUID", "UNKNOWN_SERIES"))

            ipp = getattr(dcm, "ImagePositionPatient", None)
            if ipp is not None and len(ipp) >= 3:
                z_pos = float(ipp[2])
            else:
                z_pos = float(getattr(dcm, "SliceLocation", 0.0))
        except Exception:
            patient_id = "UNKNOWN"
            series_uid = "UNKNOWN_SERIES"
            z_pos = 0.0

        records.append(
            {
                "image_id": image_id,
                "patient_id": patient_id,
                "series_uid": series_uid,
                "z_pos": z_pos,
                "dcm_path": str(dcm_path),
            }
        )

    if not records:
        return pd.DataFrame(columns=["image_id", "patient_id", "series_uid", "z_pos", "dcm_path", "prev_image_id", "next_image_id"])

    df = pd.DataFrame(records)
    df = df.sort_values(["patient_id", "series_uid", "z_pos"]).reset_index(drop=True)
    df["prev_image_id"] = df.groupby(["patient_id", "series_uid"])["image_id"].shift(1)
    df["next_image_id"] = df.groupby(["patient_id", "series_uid"])["image_id"].shift(-1)
    return df


def build_9ch_for_row(row: pd.Series, image_path_map: Dict[str, Path], mean_9: np.ndarray, std_9: np.ndarray) -> np.ndarray:
    center_id = row["image_id"]
    prev_id = row["prev_image_id"] if pd.notna(row.get("prev_image_id")) else None
    next_id = row["next_image_id"] if pd.notna(row.get("next_image_id")) else None

    center_arr = load_single_dicom_3ch(image_path_map[center_id], size=IMG_SIZE)

    if prev_id is not None and prev_id in image_path_map:
        prev_arr = load_single_dicom_3ch(image_path_map[prev_id], size=IMG_SIZE)
    else:
        prev_arr = center_arr

    if next_id is not None and next_id in image_path_map:
        next_arr = load_single_dicom_3ch(image_path_map[next_id], size=IMG_SIZE)
    else:
        next_arr = center_arr

    img_9ch = np.concatenate([prev_arr, center_arr, next_arr], axis=-1).astype(np.float32)
    img_9ch = (img_9ch - mean_9.reshape(1, 1, -1)) / (std_9.reshape(1, 1, -1) + 1e-7)
    return img_9ch


# ══════════════════════════════════════════════════════════════════════════
#  MODEL + CALIBRATION
# ══════════════════════════════════════════════════════════════════════════


def build_model(

    backbone: str = BACKBONE,

    in_ch: int = IN_CHANNELS,

    n_cls: int = N_CLASSES,

    dropout: float = DROPOUT,

    drop_path: float = DROP_PATH,

) -> nn.Module:
    model = timm.create_model(
        backbone,
        pretrained=False,
        num_classes=0,
        drop_rate=dropout,
        drop_path_rate=drop_path,
    )

    old_conv = model.conv_stem
    new_conv = nn.Conv2d(
        in_ch,
        old_conv.out_channels,
        kernel_size=old_conv.kernel_size,
        stride=old_conv.stride,
        padding=old_conv.padding,
        bias=(old_conv.bias is not None),
    )
    k = max(in_ch // 3, 1)
    with torch.no_grad():
        new_conv.weight.copy_(old_conv.weight.repeat(1, k, 1, 1) / k)
        if old_conv.bias is not None:
            new_conv.bias.copy_(old_conv.bias)
    model.conv_stem = new_conv

    n_feat = model.num_features
    model.classifier = nn.Sequential(nn.Dropout(p=dropout), nn.Linear(n_feat, n_cls))
    return model


def _find_gradcam_target_layer(model: nn.Module) -> nn.Module:
    # Prefer the last semantic convolutional stage for EfficientNet-like models.
    if hasattr(model, "conv_head") and isinstance(model.conv_head, nn.Module):
        return model.conv_head
    conv_layers = [m for m in model.modules() if isinstance(m, nn.Conv2d)]
    if not conv_layers:
        raise RuntimeError("No convolutional layer found for Grad-CAM target")
    return conv_layers[-1]


class GradCAM:
    def __init__(self, model: nn.Module):
        self.model = model
        self.activations = None
        self.gradients = None
        target = _find_gradcam_target_layer(model)
        self._fh = target.register_forward_hook(self._forward_hook)
        self._bh = target.register_full_backward_hook(self._backward_hook)

    def _forward_hook(self, _module, _inputs, output):
        self.activations = output

    def _backward_hook(self, _module, _grad_input, grad_output):
        self.gradients = grad_output[0]

    def remove(self):
        self._fh.remove()
        self._bh.remove()

    def generate(self, input_tensor: torch.Tensor, class_idx: int = 0) -> Tuple[np.ndarray, np.ndarray]:
        self.model.zero_grad(set_to_none=True)
        with torch.enable_grad():
            output = self.model(input_tensor)
            target = output[:, class_idx].sum()
            target.backward()

        logits = output.squeeze(0).detach().cpu().numpy().astype(np.float32)

        if self.activations is None or self.gradients is None:
            cam = np.zeros((IMG_SIZE, IMG_SIZE), dtype=np.float32)
            return logits, cam

        acts = self.activations.detach()
        grads = self.gradients.detach()
        weights = grads.mean(dim=(2, 3), keepdim=True)
        cam = torch.relu((weights * acts).sum(dim=1)).squeeze(0).cpu().numpy().astype(np.float32)

        if cam.size == 0 or float(cam.max()) <= 0.0:
            cam = np.zeros((IMG_SIZE, IMG_SIZE), dtype=np.float32)
        else:
            cam = (cam - cam.min()) / (cam.max() - cam.min() + 1e-8)
        return logits, cam


def make_overlay(orig_rgb_u8: np.ndarray, cam: np.ndarray, alpha: float = 0.45) -> np.ndarray:
    cam_r = cv2.resize(cam, (orig_rgb_u8.shape[1], orig_rgb_u8.shape[0]), interpolation=cv2.INTER_LINEAR)
    heat_u8 = np.uint8(np.clip(cam_r, 0.0, 1.0) * 255.0)
    heat_bgr = cv2.applyColorMap(heat_u8, cv2.COLORMAP_JET)
    heat_rgb = cv2.cvtColor(heat_bgr, cv2.COLOR_BGR2RGB)
    return (alpha * heat_rgb + (1 - alpha) * orig_rgb_u8).astype(np.uint8)


def load_models(device: str, fold_selection=None) -> Tuple[List[nn.Module], List[int]]:
    models = []
    loaded_folds: List[int] = []

    if fold_selection is None:
        fold_selection = FOLD_SELECTION

    if isinstance(fold_selection, str) and fold_selection.lower() == "ensemble":
        fold_indices = list(range(len(FOLD_MODEL_PATHS)))
    elif isinstance(fold_selection, int):
        fold_indices = [fold_selection]
    elif isinstance(fold_selection, str) and fold_selection.isdigit():
        fold_indices = [int(fold_selection)]
    else:
        raise ValueError('FOLD_SELECTION must be "ensemble" or an integer fold id (0..4).')

    for fold_idx in fold_indices:
        if fold_idx < 0 or fold_idx >= len(FOLD_MODEL_PATHS):
            print(f"  ⚠ Invalid fold index: {fold_idx} (skipping)")
            continue
        path = FOLD_MODEL_PATHS[fold_idx]
        if not path.exists():
            print(f"  ⚠ Missing fold checkpoint: {path.name} (skipping)")
            continue
        model = build_model()
        state = torch.load(str(path), map_location=device)
        model.load_state_dict(state, strict=True)
        model = model.to(device)
        model.eval()
        models.append(model)
        loaded_folds.append(fold_idx)
    return models, loaded_folds


def sigmoid_np(x: np.ndarray) -> np.ndarray:
    return 1.0 / (1.0 + np.exp(-x))


def apply_calibration(raw_logits: np.ndarray, calib_cfg: dict, iso_models) -> np.ndarray:
    best_method = calib_cfg.get("best_method", "temperature")
    temperature = float(calib_cfg.get("temperature", 1.0))

    if best_method == "isotonic" and iso_models is not None:
        raw_probs = sigmoid_np(raw_logits)
        cal_probs = np.zeros_like(raw_probs, dtype=np.float32)
        for i, subtype in enumerate(SUBTYPES):
            model_i = None
            if isinstance(iso_models, dict):
                model_i = iso_models.get(subtype)
                if model_i is None:
                    model_i = iso_models.get(i)
            elif isinstance(iso_models, (list, tuple)) and i < len(iso_models):
                model_i = iso_models[i]

            if model_i is not None:
                cal_probs[i] = float(np.clip(model_i.predict([raw_probs[i]])[0], 0.0, 1.0))
            else:
                cal_probs[i] = float(raw_probs[i])
        return cal_probs

    return sigmoid_np(raw_logits / max(temperature, 1e-6)).astype(np.float32)


def patient_aggregate(values: np.ndarray, method: str, topk: int) -> float:
    if len(values) == 0:
        return 0.0
    if method == "max":
        return float(np.max(values))
    if method == "mean":
        return float(np.mean(values))
    if method == "noisy_or":
        return float(1.0 - np.prod(1.0 - np.clip(values, 0.0, 1.0)))
    if method == "topk_mean":
        k = min(max(int(topk), 1), len(values))
        top_vals = np.sort(values)[-k:]
        return float(np.mean(top_vals))
    raise ValueError(f"Unknown PATIENT_AGG_METHOD: {method}")


# ══════════════════════════════════════════════════════════════════════════
#  REPORT HELPERS
# ══════════════════════════════════════════════════════════════════════════


def build_slice_report(

    image_id: str,

    patient_id: str,

    probs: Dict[str, float],

    calib_cfg: dict,

    threshold: float,

    loaded_folds: List[int],

    report_image_path: Optional[str] = None,

    heatmap_path: Optional[str] = None,

    true_label: Optional[int] = None,

) -> dict:
    cal_any = probs["any"]
    high_thr = float(calib_cfg.get("triage_high_thresh", 0.7))
    low_thr = float(calib_cfg.get("triage_low_thresh", 0.3))

    if cal_any >= high_thr:
        band = "HIGH"
    elif cal_any >= low_thr:
        band = "MEDIUM"
    else:
        band = "LOW"

    is_positive = cal_any >= threshold
    outcome_key = "POSITIVE" if is_positive else "NEGATIVE"

    report = {
        "report_id": f"RPT_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}_{image_id[-8:]}",
        "generated_at": datetime.datetime.now(datetime.timezone.utc).isoformat(),
        "image_id": image_id,
        "patient_id": patient_id,
        "ground_truth_any": int(true_label) if true_label is not None else "N/A",
        "screening_module": {
            "version": "2.0",
            "architecture": BACKBONE,
            "input_type": "2.5D (9ch: prev+center+next)",
            "ensemble": "ensemble" if len(loaded_folds) > 1 else "single-fold",
            "folds_used": loaded_folds,
            "calibration_method": calib_cfg.get("best_method", "temperature"),
        },
        "prediction": {
            "screening_outcome": OUTCOME_POSITIVE if is_positive else OUTCOME_NEGATIVE,
            "decision_threshold_any": round(float(threshold), 6),
            "confidence_band": band,
            "confidence_band_label": BAND_LABELS[band],
            **{f"calibrated_prob_{k}": round(float(v), 6) for k, v in probs.items()},
        },
        "triage": {
            "action": TRIAGE_ACTIONS[(outcome_key, band)],
            "urgency": "URGENT" if (is_positive and band == "HIGH") else "STANDARD",
        },
        "disclaimer": DISCLAIMER,
    }

    if report_image_path or heatmap_path:
        report["explainability"] = {
            "method": "Gradient-weighted Class Activation Mapping (Grad-CAM)",
            "image_path": report_image_path,
            "heatmap_path": heatmap_path,
            "note": (
                "Highlighted regions indicate areas with greatest influence on the "
                "screening decision. These are not confirmed anatomical findings."
            ),
        }

    return report


# ══════════════════════════════════════════════════════════════════════════
#  MAIN
# ══════════════════════════════════════════════════════════════════════════


def main():
    print("=" * 72)
    print("  ICH SCREENING — Improved 2.5D Inference")
    print("=" * 72)

    if not has_pydicom:
        print("ERROR: pydicom is not installed. Run: pip install pydicom")
        return

    if not DICOM_INPUT_DIR.exists():
        print(f"ERROR: DICOM input folder not found: {DICOM_INPUT_DIR}")
        print("  Create this folder and place .dcm files inside it.")
        return

    for path in [CALIB_PARAMS_PATH, NORM_STATS_PATH]:
        if not path.exists():
            print(f"ERROR: Required file missing: {path}")
            return

    device = "cuda" if torch.cuda.is_available() else "cpu"
    print(f"\n  Device            : {device}")

    with open(NORM_STATS_PATH, "r", encoding="utf-8") as f:
        norm = json.load(f)
    mean_9 = np.asarray(norm["mean_9ch"], dtype=np.float32)
    std_9 = np.asarray(norm["std_9ch"], dtype=np.float32)

    with open(CALIB_PARAMS_PATH, "r", encoding="utf-8") as f:
        calib_cfg = json.load(f)

    iso_models = None
    if ISOTONIC_MODELS_PATH.exists():
        with open(ISOTONIC_MODELS_PATH, "rb") as f:
            iso_models = pickle.load(f)

    threshold = (
        float(DECISION_THRESHOLD)
        if DECISION_THRESHOLD is not None
        else float(calib_cfg.get("threshold_at_spec90", 0.5))
    )

    print(f"  Backbone          : {BACKBONE}")
    print(f"  Input             : {IN_CHANNELS}ch @ {IMG_SIZE}x{IMG_SIZE}")
    print(f"  Calibration       : {calib_cfg.get('best_method', 'temperature')}")
    print(f"  Decision threshold: {threshold:.6f}")

    models, loaded_folds = load_models(device, fold_selection=FOLD_SELECTION)
    if not models:
        print("ERROR: No fold checkpoints could be loaded.")
        return
    print(f"  Fold models loaded: {len(models)} (folds: {loaded_folds})")
    gradcam_objects = [GradCAM(m) for m in models] if GENERATE_HEATMAPS else []

    adjacency_df = build_adjacency(DICOM_INPUT_DIR)
    if adjacency_df.empty:
        print(f"ERROR: No .dcm files found in {DICOM_INPUT_DIR}")
        return

    image_path_map = {
        Path(p).stem: Path(p)
        for p in adjacency_df["dcm_path"].tolist()
    }

    label_map: Dict[str, int] = {}
    if MANIFEST_PATH.exists():
        try:
            manifest = pd.read_csv(MANIFEST_PATH)
            if "image_id" in manifest.columns and "any" in manifest.columns:
                label_map = dict(zip(manifest["image_id"], manifest["any"]))
                print(f"  Manifest labels   : loaded {len(label_map)} rows")
        except Exception as exc:
            print(f"  ⚠ Manifest load skipped: {exc}")

    reports_dir = OUTPUT_DIR / "reports"
    reports_dir.mkdir(parents=True, exist_ok=True)

    print(f"\n{'─' * 72}")
    print(f"  Processing {len(adjacency_df)} DICOM slices")
    print(f"{'─' * 72}\n")

    slice_rows = []
    report_summary_rows = []
    patient_probs: Dict[str, List[float]] = {}

    for i, row in adjacency_df.iterrows():
        image_id = row["image_id"]
        patient_id = row["patient_id"]

        try:
            img_9ch = build_9ch_for_row(row, image_path_map, mean_9=mean_9, std_9=std_9)
        except Exception as exc:
            print(f"  [{i+1}/{len(adjacency_df)}] SKIP {image_id}: {exc}")
            continue

        tensor = torch.from_numpy(img_9ch).permute(2, 0, 1).unsqueeze(0).to(device)

        fold_logits = []
        fold_cams = []
        if GENERATE_HEATMAPS:
            for model, cam_obj in zip(models, gradcam_objects):
                logits, cam = cam_obj.generate(tensor, class_idx=0)
                fold_logits.append(logits)
                fold_cams.append(cam)
        else:
            with torch.no_grad():
                for model in models:
                    logits = model(tensor).squeeze(0).detach().cpu().numpy().astype(np.float32)
                    fold_logits.append(logits)

        mean_logits = np.mean(np.stack(fold_logits, axis=0), axis=0)
        raw_probs = sigmoid_np(mean_logits)
        cal_probs = apply_calibration(mean_logits, calib_cfg, iso_models)

        probs_dict = {name: float(cal_probs[j]) for j, name in enumerate(SUBTYPES)}

        # Save a per-slice visualization image (windowed center slice) for report artifacts.
        preview_path = reports_dir / f"{image_id}_preview.png"
        heatmap_path = reports_dir / f"{image_id}_gradcam.png"
        try:
            center_rgb = load_single_dicom_3ch(Path(row["dcm_path"]), size=IMG_SIZE)
            center_rgb_u8 = (np.clip(center_rgb, 0.0, 1.0) * 255.0).astype(np.uint8)
            cv2.imwrite(str(preview_path), cv2.cvtColor(center_rgb_u8, cv2.COLOR_RGB2BGR))
            if GENERATE_HEATMAPS:
                if fold_cams:
                    mean_cam = np.mean(np.stack(fold_cams, axis=0), axis=0)
                else:
                    mean_cam = np.zeros((IMG_SIZE, IMG_SIZE), dtype=np.float32)
                overlay_rgb = make_overlay(center_rgb_u8, mean_cam, alpha=0.45)
                cv2.imwrite(str(heatmap_path), cv2.cvtColor(overlay_rgb, cv2.COLOR_RGB2BGR))
            report_image_path = str(preview_path)
            report_heatmap_path = str(heatmap_path) if GENERATE_HEATMAPS else ""
        except Exception:
            report_image_path = ""
            report_heatmap_path = ""

        true_any = label_map.get(image_id)
        rep = build_slice_report(
            image_id=image_id,
            patient_id=patient_id,
            probs=probs_dict,
            calib_cfg=calib_cfg,
            threshold=threshold,
            loaded_folds=loaded_folds,
            report_image_path=report_image_path,
            heatmap_path=report_heatmap_path,
            true_label=int(true_any) if true_any is not None else None,
        )

        report_path = reports_dir / f"{image_id}_report.json"
        with open(report_path, "w", encoding="utf-8") as f:
            json.dump(rep, f, indent=2)

        slice_rows.append(
            {
                "image_id": image_id,
                "patient_id": patient_id,
                "true_any": int(true_any) if true_any is not None else "",
                "pred_any": int(probs_dict["any"] >= threshold),
                "cal_any": round(probs_dict["any"], 6),
                "raw_any": round(float(raw_probs[0]), 6),
                **{f"cal_{name}": round(float(probs_dict[name]), 6) for name in SUBTYPES[1:]},
                "confidence_band": rep["prediction"]["confidence_band"],
                "triage_action": rep["triage"]["action"],
                "urgency": rep["triage"]["urgency"],
            }
        )

        report_summary_rows.append(
            {
                "image_id": image_id,
                "true_label": int(true_any) if true_any is not None else "",
                "screening_outcome": rep["prediction"]["screening_outcome"],
                "raw_prob": round(float(raw_probs[0]), 6),
                "cal_prob": round(float(probs_dict["any"]), 6),
                "confidence_band": rep["prediction"]["confidence_band"],
                "triage_action": rep["triage"]["action"],
                "urgency": rep["triage"]["urgency"],
                "image_path": report_image_path,
                "heatmap_path": report_heatmap_path,
            }
        )

        patient_probs.setdefault(patient_id, []).append(probs_dict["any"])

        status = "[+] POS" if probs_dict["any"] >= threshold else "[-] NEG"
        print(
            f"  [{i+1}/{len(adjacency_df)}] {image_id}  →  {status}  "
            f"cal_any={probs_dict['any']:.4f}"
        )

    if not slice_rows:
        print("\nERROR: No slices were processed successfully.")
        return

    slice_df = pd.DataFrame(slice_rows)
    slice_csv_path = OUTPUT_DIR / "slice_predictions.csv"
    slice_df.to_csv(slice_csv_path, index=False)

    report_summary_df = pd.DataFrame(report_summary_rows)
    report_summary_csv_path = OUTPUT_DIR / "report_summary.csv"
    report_summary_df.to_csv(report_summary_csv_path, index=False)

    patient_rows = []
    for pid, vals in patient_probs.items():
        arr = np.asarray(vals, dtype=np.float32)
        agg_prob = patient_aggregate(arr, PATIENT_AGG_METHOD, PATIENT_TOPK)
        patient_rows.append(
            {
                "patient_id": pid,
                "n_slices": int(len(arr)),
                "agg_method": PATIENT_AGG_METHOD,
                "agg_any_probability": round(float(agg_prob), 6),
                "pred_any": int(agg_prob >= threshold),
            }
        )

    patient_df = pd.DataFrame(patient_rows)
    patient_csv_path = OUTPUT_DIR / "patient_predictions.csv"
    patient_df.to_csv(patient_csv_path, index=False)

    for cam_obj in gradcam_objects:
        cam_obj.remove()

    n_pos = int((slice_df["pred_any"] == 1).sum())
    n_total = len(slice_df)
    n_urgent = int((slice_df["urgency"] == "URGENT").sum())

    print(f"\n{'═' * 72}")
    print("  INFERENCE COMPLETE")
    print(f"{'═' * 72}")
    print(f"  Slices processed   : {n_total}")
    print(f"  Positive slices    : {n_pos}")
    print(f"  Urgent escalations : {n_urgent}")
    print(f"  Patients processed : {len(patient_df)}")
    print("\n  Outputs:")
    print(f"    JSON reports     : {reports_dir}")
    print(f"    Report images    : {reports_dir}")
    print(f"    Report summary   : {report_summary_csv_path}")
    print(f"    Slice CSV        : {slice_csv_path}")
    print(f"    Patient CSV      : {patient_csv_path}")
    print(f"{'═' * 72}")


if __name__ == "__main__":
    main()