from __future__ import annotations import math from dataclasses import dataclass from pathlib import Path from typing import Literal import numpy as np import pandas as pd import torch from torch.utils.data import Dataset PHASES = ("native", "arterial", "portal", "delayed") DEFAULT_CLEAN_CLINICAL_COLUMNS = ( "age", "gender_woman", "etiology_mixed", "etiology_HCV", "etiology_HBV", "etiology_alcoholic", "etiology_NASH", "etiology_cryptogenic", "lesions_number", "lesion1_localisation", "lesion1_diameter", "lesion1_LIRADS", "lesion2_localisation", "lesion2_diameter", "lesion2_LIRADS", "lesion3_localisation", "lesion3_diameter", "lesion3_LIRADS", "biopsy", "lab_albumin", "lab_creatinine", "lab_bilirubin", "lab_afp", "lab_inr", "lab_alt", "cps", "bclc", "hap_score", "mhap_2", "albi_tae", ) @dataclass(frozen=True) class ClinicalStats: mean: np.ndarray std: np.ndarray def make_split( manifest_path: str | Path, val_fraction: float, seed: int, stratify_column: str | None = None, ) -> tuple[pd.DataFrame, pd.DataFrame]: df = pd.read_csv(manifest_path) rng = np.random.default_rng(seed) if stratify_column and stratify_column in df.columns: train_parts = [] val_parts = [] for _, group in df.groupby(stratify_column, dropna=False): idx = group.index.to_numpy() rng.shuffle(idx) n_val = max(1, int(round(len(idx) * val_fraction))) if len(idx) > 1 else 0 val_idx = idx[:n_val] train_idx = idx[n_val:] train_parts.append(df.loc[train_idx]) val_parts.append(df.loc[val_idx]) train_df = pd.concat(train_parts).sample(frac=1.0, random_state=seed).reset_index(drop=True) val_df = pd.concat(val_parts).sample(frac=1.0, random_state=seed).reset_index(drop=True) else: idx = df.index.to_numpy() rng.shuffle(idx) n_val = max(1, int(round(len(idx) * val_fraction))) val_df = df.loc[idx[:n_val]].reset_index(drop=True) train_df = df.loc[idx[n_val:]].reset_index(drop=True) return train_df, val_df def compute_clinical_stats(df: pd.DataFrame, root: str | Path) -> ClinicalStats: values = [] root = Path(root) for path in df["npz_path"].tolist(): with np.load(root / path) as z: if "clinical_values" in z: values.append(z["clinical_values"].astype(np.float32)) if not values: return ClinicalStats(np.zeros(0, dtype=np.float32), np.ones(0, dtype=np.float32)) arr = np.stack(values, axis=0) mean = arr.mean(axis=0) std = arr.std(axis=0) std[std < 1e-6] = 1.0 return ClinicalStats(mean.astype(np.float32), std.astype(np.float32)) def load_clean_clinical_table( path: str | Path, columns: tuple[str, ...] | list[str] | None = None, ) -> pd.DataFrame: table = pd.read_csv(path) if "patient_id" not in table.columns: raise ValueError(f"Clinical table must contain patient_id: {path}") selected = list(columns or DEFAULT_CLEAN_CLINICAL_COLUMNS) selected = [col for col in selected if col in table.columns] if not selected: raise ValueError(f"No selected clinical columns found in {path}") out = table[["patient_id", *selected]].copy() def normalize_id(value) -> str: try: numeric = float(value) if np.isfinite(numeric) and numeric.is_integer(): return str(int(numeric)) except Exception: pass return str(value) out["patient_id"] = out["patient_id"].map(normalize_id) for col in selected: out[col] = pd.to_numeric(out[col], errors="coerce") usable = [col for col in selected if not out[col].isna().all()] out = out[["patient_id", *usable]] return out.set_index("patient_id") def compute_clinical_stats_from_table(df: pd.DataFrame, table: pd.DataFrame) -> ClinicalStats: values = [] for _, row in df.iterrows(): patient_id = str(row.get("patient_id", row.get("case_id"))) if patient_id in table.index: values.append(table.loc[patient_id].to_numpy(dtype=np.float32)) if not values: return ClinicalStats(np.zeros(table.shape[1], dtype=np.float32), np.ones(table.shape[1], dtype=np.float32)) arr = np.stack(values, axis=0) mean = np.nanmean(arr, axis=0) std = np.nanstd(arr, axis=0) mean = np.nan_to_num(mean, nan=0.0, posinf=0.0, neginf=0.0) std = np.nan_to_num(std, nan=1.0, posinf=1.0, neginf=1.0) std[std < 1e-6] = 1.0 return ClinicalStats(mean.astype(np.float32), std.astype(np.float32)) def label_from_masks(liver: np.ndarray, tumor: np.ndarray) -> np.ndarray: label = (liver > 0).astype(np.uint8) label[tumor > 0] = 2 return label def _pad_to_shape(array: np.ndarray, spatial_shape: tuple[int, int, int], value: float = 0) -> np.ndarray: current = array.shape[-3:] pads = [] for cur, target in zip(reversed(current), reversed(spatial_shape)): deficit = max(0, target - cur) before = deficit // 2 after = deficit - before pads.append((before, after)) pad_width = [(0, 0)] * (array.ndim - 3) + list(reversed(pads)) if any(a or b for a, b in pad_width): array = np.pad(array, pad_width, mode="constant", constant_values=value) return array def _crop_slices( spatial_shape: tuple[int, int, int], patch_shape: tuple[int, int, int], center: np.ndarray | None, rng: np.random.Generator, mode: Literal["random", "center"], ) -> tuple[slice, slice, slice]: starts = [] for axis, (size, patch) in enumerate(zip(spatial_shape, patch_shape)): max_start = max(0, size - patch) if mode == "center": start = max_start // 2 elif center is not None: low = int(center[axis] - patch + 1) high = int(center[axis]) start = int(rng.integers(max(0, low), min(max_start, high) + 1)) else: start = int(rng.integers(0, max_start + 1)) starts.append(start) return tuple(slice(starts[i], starts[i] + patch_shape[i]) for i in range(3)) # type: ignore[return-value] def crop_or_pad_patch( image: np.ndarray, label: np.ndarray, patch_shape: tuple[int, int, int], rng: np.random.Generator, train: bool, foreground_prob: float, ) -> tuple[np.ndarray, np.ndarray]: image = _pad_to_shape(image, patch_shape, value=0) label = _pad_to_shape(label, patch_shape, value=0) mode: Literal["random", "center"] = "random" if train else "center" center = None if train and rng.random() < foreground_prob: candidates = np.argwhere(label == 2) if candidates.size == 0: candidates = np.argwhere(label > 0) if candidates.size: center = candidates[int(rng.integers(0, len(candidates)))] slices = _crop_slices(label.shape[-3:], patch_shape, center, rng, mode) return image[(..., *slices)].astype(np.float32), label[slices].astype(np.int64) def tumor_volume_from_npz(path: str | Path, root: str | Path) -> int: with np.load(Path(root) / path) as z: if "tumor_mask" in z: return int((z["tumor_mask"] > 0).sum()) if "label" in z: return int((z["label"] == 2).sum()) return 0 def random_spatial_augment(image: np.ndarray, label: np.ndarray, rng: np.random.Generator) -> tuple[np.ndarray, np.ndarray]: for spatial_axis in range(3): if rng.random() < 0.5: image = np.flip(image, axis=spatial_axis + 1) label = np.flip(label, axis=spatial_axis) return image.copy(), label.copy() def random_intensity_augment(image: np.ndarray, rng: np.random.Generator) -> np.ndarray: if rng.random() < 0.5: scale = float(rng.uniform(0.9, 1.1)) shift = float(rng.uniform(-0.05, 0.05)) image = np.clip(image * scale + shift, 0.0, 1.0) if rng.random() < 0.15: noise = rng.normal(0.0, 0.015, size=image.shape).astype(np.float32) image = np.clip(image + noise, 0.0, 1.0) return image.astype(np.float32) class SegmentationNPZDataset(Dataset): def __init__( self, frame: pd.DataFrame, root: str | Path, patch_shape: tuple[int, int, int], train: bool, seed: int, foreground_prob: float = 0.8, target_channels: int = 1, ) -> None: self.frame = frame.reset_index(drop=True) self.root = Path(root) self.patch_shape = patch_shape self.train = train self.seed = seed self.foreground_prob = foreground_prob self.target_channels = target_channels self.epoch = 0 def __len__(self) -> int: return len(self.frame) def set_epoch(self, epoch: int) -> None: self.epoch = int(epoch) def _rng_for_index(self, index: int) -> np.random.Generator: offset = self.epoch * 1_000_003 if self.train else 10_000_000 return np.random.default_rng(self.seed + index + offset) def __getitem__(self, index: int) -> dict[str, torch.Tensor | str]: row = self.frame.iloc[index] rng = self._rng_for_index(index) with np.load(self.root / row["npz_path"]) as z: image = z["image"].astype(np.float32) if "label" in z: label = z["label"].astype(np.uint8) else: label = label_from_masks(z["liver_mask"], z["tumor_mask"]) if image.shape[0] != self.target_channels: if image.shape[0] > self.target_channels: image = image[: self.target_channels] else: pad = np.zeros((self.target_channels - image.shape[0], *image.shape[1:]), dtype=image.dtype) image = np.concatenate([image, pad], axis=0) image, label = crop_or_pad_patch(image, label, self.patch_shape, rng, self.train, self.foreground_prob) if self.train: image, label = random_spatial_augment(image, label, rng) image = random_intensity_augment(image, rng) return { "image": torch.from_numpy(image), "seg_label": torch.from_numpy(label), "case_id": str(row.get("case_id", row.get("patient_id", index))), } class WAWTaceDataset(Dataset): def __init__( self, frame: pd.DataFrame, root: str | Path, patch_shape: tuple[int, int, int], train: bool, seed: int, clinical_stats: ClinicalStats, foreground_prob: float = 0.8, survival_bins_days: tuple[float, ...] = (180, 365, 540, 730, 1095), clinical_table: pd.DataFrame | None = None, phase_dropout_prob: float = 0.0, single_phase_prob: float = 0.0, ) -> None: self.frame = frame.reset_index(drop=True) self.root = Path(root) self.patch_shape = patch_shape self.train = train self.seed = seed self.clinical_stats = clinical_stats self.clinical_table = clinical_table self.foreground_prob = foreground_prob self.phase_dropout_prob = phase_dropout_prob self.single_phase_prob = single_phase_prob self.survival_bins_days = np.asarray(survival_bins_days, dtype=np.float32) self.sample_weights = ( self.frame["sample_weight"].astype(np.float32).to_numpy() if "sample_weight" in self.frame.columns else np.ones(len(self.frame), dtype=np.float32) ) self.epoch = 0 def __len__(self) -> int: return len(self.frame) def set_epoch(self, epoch: int) -> None: self.epoch = int(epoch) def _rng_for_index(self, index: int) -> np.random.Generator: offset = self.epoch * 1_000_003 if self.train else 10_000_000 return np.random.default_rng(self.seed + index + offset) def _survival_target(self, time_value: float, event_value: float) -> tuple[np.ndarray, np.ndarray, np.ndarray]: n_bins = len(self.survival_bins_days) if not math.isfinite(time_value) or not math.isfinite(event_value): return ( np.asarray(-1, dtype=np.int64), np.asarray(0.0, dtype=np.float32), np.zeros(n_bins, dtype=np.float32), ) bin_index = int(np.searchsorted(self.survival_bins_days, float(time_value), side="right")) bin_index = min(bin_index, n_bins - 1) at_risk = np.zeros(n_bins, dtype=np.float32) at_risk[: bin_index + 1] = 1.0 return np.asarray(bin_index, dtype=np.int64), np.asarray(float(event_value), dtype=np.float32), at_risk def __getitem__(self, index: int) -> dict[str, torch.Tensor | str]: row = self.frame.iloc[index] rng = self._rng_for_index(index) with np.load(self.root / row["npz_path"]) as z: image = z["image"].astype(np.float32) label = label_from_masks(z["liver_mask"], z["tumor_mask"]) phase_available = z["phase_available"].astype(np.float32) clinical_values = z["clinical_values"].astype(np.float32) clinical_missing = z["clinical_missing"].astype(np.float32) response = z["label_response"].astype(np.float32)[0] progression = z["label_progression"].astype(np.float32)[0] time_pfs = z["time_pfs"].astype(np.float32)[0] event_pfs = z["event_pfs"].astype(np.float32)[0] time_os = z["time_os"].astype(np.float32)[0] event_os = z["event_os"].astype(np.float32)[0] time_ttp = z["time_ttp"].astype(np.float32)[0] event_ttp = z["event_ttp"].astype(np.float32)[0] if self.train: available_idx = np.flatnonzero(phase_available > 0) if available_idx.size > 1 and self.single_phase_prob > 0 and rng.random() < self.single_phase_prob: keep = int(available_idx[int(rng.integers(0, len(available_idx)))]) reference = image[keep].copy() image[:] = reference[None, ...] phase_available[:] = 0.0 phase_available[keep] = 1.0 elif available_idx.size > 1 and self.phase_dropout_prob > 0: drop_mask = (rng.random(len(available_idx)) < self.phase_dropout_prob) if drop_mask.any() and not drop_mask.all(): drop_idx = available_idx[drop_mask] image[drop_idx] = 0.0 phase_available[drop_idx] = 0.0 if self.clinical_table is not None: patient_id = str(row.get("patient_id", row.get("case_id"))) if patient_id in self.clinical_table.index: clinical_values = self.clinical_table.loc[patient_id].to_numpy(dtype=np.float32) else: clinical_values = np.full(self.clinical_table.shape[1], np.nan, dtype=np.float32) clinical_missing = np.isnan(clinical_values).astype(np.uint8) clinical_values = np.nan_to_num(clinical_values, nan=0.0) image, label = crop_or_pad_patch(image, label, self.patch_shape, rng, self.train, self.foreground_prob) if self.train: image, label = random_spatial_augment(image, label, rng) image = random_intensity_augment(image, rng) if self.clinical_stats.mean.size: clinical_values = (clinical_values - self.clinical_stats.mean) / self.clinical_stats.std clinical_values = np.nan_to_num(clinical_values, nan=0.0, posinf=0.0, neginf=0.0) pfs_bin, pfs_event, pfs_at_risk = self._survival_target(float(time_pfs), float(event_pfs)) os_bin, os_event, os_at_risk = self._survival_target(float(time_os), float(event_os)) ttp_bin, ttp_event, ttp_at_risk = self._survival_target(float(time_ttp), float(event_ttp)) response_valid = np.asarray(math.isfinite(float(response)), dtype=np.float32) response_value = np.asarray(0 if not response_valid else int(response), dtype=np.int64) progression_valid = np.asarray(math.isfinite(float(progression)), dtype=np.float32) progression_value = np.asarray(0.0 if not progression_valid else float(progression), dtype=np.float32) return { "image": torch.from_numpy(image), "seg_label": torch.from_numpy(label), "phase_available": torch.from_numpy(phase_available), "clinical_values": torch.from_numpy(clinical_values.astype(np.float32)), "clinical_missing": torch.from_numpy(clinical_missing.astype(np.float32)), "response": torch.from_numpy(response_value.reshape(())), "response_valid": torch.from_numpy(response_valid.reshape(())), "progression": torch.from_numpy(progression_value.reshape(())), "progression_valid": torch.from_numpy(progression_valid.reshape(())), "pfs_bin": torch.from_numpy(pfs_bin.reshape(())), "pfs_event": torch.from_numpy(pfs_event.reshape(())), "pfs_at_risk": torch.from_numpy(pfs_at_risk), "pfs_time": torch.tensor(float(time_pfs) if math.isfinite(float(time_pfs)) else -1.0, dtype=torch.float32), "os_bin": torch.from_numpy(os_bin.reshape(())), "os_event": torch.from_numpy(os_event.reshape(())), "os_at_risk": torch.from_numpy(os_at_risk), "os_time": torch.tensor(float(time_os) if math.isfinite(float(time_os)) else -1.0, dtype=torch.float32), "ttp_bin": torch.from_numpy(ttp_bin.reshape(())), "ttp_event": torch.from_numpy(ttp_event.reshape(())), "ttp_at_risk": torch.from_numpy(ttp_at_risk), "ttp_time": torch.tensor(float(time_ttp) if math.isfinite(float(time_ttp)) else -1.0, dtype=torch.float32), "case_id": str(row.get("case_id", row.get("patient_id", index))), }