| 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)) |
|
|
|
|
| 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))), |
| } |
|
|
