Upload 16 files

milk10k_effb2_metadata/__init__.py

@@ -0,0 +1,2 @@
+"""EfficientNet-B2 dual-branch MILK10k metadata trainer."""
+

milk10k_effb2_metadata/checkpoints.py

@@ -0,0 +1,92 @@
+"""Checkpoint loading utilities for mixed timm/torchvision EfficientNet-B2 branches."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Any
+
+import torch
+from torch import nn
+
+CHECKPOINT_STATE_KEYS = ("model_state", "model_state_dict", "state_dict")
+PREFIXES_TO_STRIP = ("module.", "model.", "_orig_mod.")
+
+
+def extract_state_dict(checkpoint: Any) -> dict[str, torch.Tensor]:
+    if isinstance(checkpoint, dict):
+        for key in CHECKPOINT_STATE_KEYS:
+            value = checkpoint.get(key)
+            if isinstance(value, dict):
+                return value
+    if isinstance(checkpoint, dict) and all(torch.is_tensor(value) for value in checkpoint.values()):
+        return checkpoint
+    raise ValueError("Checkpoint does not contain a supported state dict.")
+
+
+def load_raw_checkpoint(path: Path, device: torch.device, branch_name: str) -> Any:
+    if not path.exists():
+        raise FileNotFoundError(f"{branch_name} checkpoint not found: {path}")
+    try:
+        return torch.load(path, map_location=device, weights_only=False)
+    except TypeError:
+        return torch.load(path, map_location=device)
+
+
+def normalize_key(key: str) -> str:
+    changed = True
+    while changed:
+        changed = False
+        for prefix in PREFIXES_TO_STRIP:
+            if key.startswith(prefix):
+                key = key.removeprefix(prefix)
+                changed = True
+    return key
+
+
+def infer_checkpoint_backend(path: Path, device: torch.device, branch_name: str) -> str:
+    checkpoint = load_raw_checkpoint(path, device, branch_name)
+    state = extract_state_dict(checkpoint)
+    keys = {normalize_key(key) for key in state}
+    timm_prefixes = ("conv_stem.", "bn1.", "blocks.", "conv_head.", "bn2.")
+    torchvision_prefixes = ("features.", "avgpool.", "classifier.")
+    timm_hits = sum(key.startswith(timm_prefixes) for key in keys)
+    torchvision_hits = sum(key.startswith(torchvision_prefixes) for key in keys)
+    if timm_hits > torchvision_hits:
+        return "timm"
+    if torchvision_hits > timm_hits:
+        return "torchvision"
+    raise RuntimeError(
+        f"{branch_name}: cannot infer checkpoint backend from {path}. "
+        "Pass --backbone-backend timm or --backbone-backend torchvision explicitly."
+    )
+
+
+def resolve_backbone_backends(args: argparse.Namespace, device: torch.device) -> tuple[str, str]:
+    if args.backbone_backend != "auto":
+        return args.backbone_backend, args.backbone_backend
+
+    clinical_backend = infer_checkpoint_backend(args.clinical_checkpoint, device, "clinical")
+    dermoscopic_backend = infer_checkpoint_backend(args.dermoscopic_checkpoint, device, "dermoscopic")
+    print(f"Auto-detected backbone backends: clinical={clinical_backend}, dermoscopic={dermoscopic_backend}")
+    return clinical_backend, dermoscopic_backend
+
+
+def load_encoder_checkpoint(path: Path, encoder: nn.Module, branch_name: str, device: torch.device) -> None:
+    checkpoint = load_raw_checkpoint(path, device, branch_name)
+    raw_state = extract_state_dict(checkpoint)
+    source_state = {normalize_key(key): value for key, value in raw_state.items()}
+    target_state = encoder.state_dict()
+    matched = {
+        key: value
+        for key, value in source_state.items()
+        if key in target_state and tuple(value.shape) == tuple(target_state[key].shape)
+    }
+    skipped = len(source_state) - len(matched)
+    if not matched:
+        raise RuntimeError(f"{branch_name}: no matching encoder weights loaded from {path}")
+
+    target_state.update(matched)
+    encoder.load_state_dict(target_state)
+    print(f"{branch_name}: loaded {len(matched)} keys from {path}; skipped {skipped} keys")
+

milk10k_effb2_metadata/cli.py

@@ -0,0 +1,58 @@
+"""CLI for the EfficientNet-B2 dual metadata trainer."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Train MILK10k dual EfficientNet-B2 with metadata fusion.")
+    parser.add_argument("--data-dir", type=Path, default=None)
+    parser.add_argument("--clinical-checkpoint", type=Path, required=True)
+    parser.add_argument("--dermoscopic-checkpoint", type=Path, required=True)
+    parser.add_argument("--output-dir", type=Path, default=Path("milk10k_dual_effb2_metadata_runs"))
+    parser.add_argument("--freeze-epochs", type=int, default=8)
+    parser.add_argument("--finetune-epochs", type=int, default=20)
+    parser.add_argument("--batch-size", type=int, default=8)
+    parser.add_argument("--image-size", type=int, default=260)
+    parser.add_argument(
+        "--num-workers",
+        type=int,
+        default=0,
+        help="DataLoader workers. Keep 0 in small Docker/Marimo containers to avoid /dev/shm exhaustion.",
+    )
+    parser.add_argument("--head-lr", type=float, default=1e-4)
+    parser.add_argument("--encoder-lr", type=float, default=1e-5)
+    parser.add_argument("--weight-decay", type=float, default=1e-4)
+    parser.add_argument("--val-size", type=float, default=0.20)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--branch-dim", type=int, default=512)
+    parser.add_argument("--metadata-dim", type=int, default=64)
+    parser.add_argument("--classifier-hidden-dim", type=int, default=512)
+    parser.add_argument("--dropout", type=float, default=0.3)
+    parser.add_argument("--class-weight", action="store_true")
+    parser.add_argument("--weighted-sampler", action="store_true")
+    parser.add_argument("--sampler-power", type=float, default=1.0)
+    parser.add_argument("--loss", choices=["ce", "focal", "milk_lt"], default="ce")
+    parser.add_argument("--focal-gamma", type=float, default=2.0)
+    parser.add_argument("--lt-beta", type=float, default=0.9999)
+    parser.add_argument("--lt-max-margin", type=float, default=0.5)
+    parser.add_argument("--lt-logit-tau", type=float, default=1.0)
+    parser.add_argument("--lt-draw-start-epoch", "--lt-drw-start-epoch", dest="lt_draw_start_epoch", type=int, default=0)
+    parser.add_argument("--lt-alpha-max", type=float, default=10.0)
+    parser.add_argument("--k-folds", type=int, default=1)
+    parser.add_argument("--amp", action="store_true")
+    parser.add_argument(
+        "--backbone-backend",
+        choices=["auto", "timm", "torchvision"],
+        default="auto",
+        help="Backbone implementation used by checkpoints. auto detects timm vs torchvision from checkpoint keys.",
+    )
+    parser.add_argument(
+        "--imagenet-pretrained",
+        action="store_true",
+        help="Initialize EfficientNet-B2 with ImageNet weights before loading branch checkpoints.",
+    )
+    parser.add_argument("--patience", type=int, default=6)
+    return parser.parse_args()

milk10k_effb2_metadata/data.py

@@ -0,0 +1,262 @@
+"""Dataframe, metadata, split, and dataloader helpers."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+import torch
+from PIL import Image, ImageFile
+from sklearn.model_selection import StratifiedKFold, train_test_split
+from torch.utils.data import DataLoader, Dataset, WeightedRandomSampler
+from torchvision import transforms
+
+from datasets import LABEL_COLUMNS, normalize_image_type
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+METADATA_COLUMNS = ("age_approx", "sex", "skin_tone_class", "site")
+
+
+class PairedMilk10kMetadataDataset(Dataset):
+    def __init__(
+        self,
+        df: pd.DataFrame,
+        label_to_idx: dict[str, int],
+        metadata_spec: dict[str, Any],
+        transform=None,
+    ) -> None:
+        self.df = df.reset_index(drop=True)
+        self.labels = [label_to_idx[label] for label in self.df["label"].tolist()]
+        self.metadata = np.stack([metadata_vector(row, metadata_spec) for _, row in self.df.iterrows()])
+        self.transform = transform
+
+    def __len__(self) -> int:
+        return len(self.df)
+
+    def _load_image(self, path: str) -> torch.Tensor:
+        with Image.open(path) as img:
+            image = img.convert("RGB")
+        if self.transform is not None:
+            image = self.transform(image)
+        return image
+
+    def __getitem__(self, idx: int) -> dict[str, torch.Tensor]:
+        row = self.df.iloc[idx]
+        return {
+            "clinical": self._load_image(row["clinical_path"]),
+            "dermoscopic": self._load_image(row["dermoscopic_path"]),
+            "metadata": torch.from_numpy(self.metadata[idx]),
+            "label": torch.tensor(self.labels[idx], dtype=torch.long),
+        }
+
+
+def load_paired_dataframe(data_dir: Path) -> pd.DataFrame:
+    input_dir = data_dir / "MILK10k_Training_Input"
+    gt = pd.read_csv(data_dir / "MILK10k_Training_GroundTruth.csv")
+    meta = pd.read_csv(data_dir / "MILK10k_Training_Metadata.csv")
+    monet_columns = resolve_monet_columns(meta)
+
+    gt["label"] = gt[LABEL_COLUMNS].idxmax(axis=1)
+    meta["image_type_norm"] = meta["image_type"].map(normalize_image_type)
+    meta["path"] = meta.apply(lambda r: input_dir / r["lesion_id"] / f"{r['isic_id']}.jpg", axis=1)
+    meta = meta[meta["path"].map(lambda p: p.exists())].copy()
+    meta["path"] = meta["path"].map(str)
+
+    keep = ["lesion_id", "path", *METADATA_COLUMNS, *monet_columns]
+    clinical = meta[meta["image_type_norm"] == "clinical_close_up"][keep].drop_duplicates("lesion_id")
+    dermoscopic = meta[meta["image_type_norm"] == "dermoscopic"][keep].drop_duplicates("lesion_id")
+    paired = (
+        gt[["lesion_id", "label"]]
+        .merge(clinical.add_prefix("clinical_"), left_on="lesion_id", right_on="clinical_lesion_id")
+        .merge(dermoscopic.add_prefix("dermoscopic_"), left_on="lesion_id", right_on="dermoscopic_lesion_id")
+        .drop(columns=["clinical_lesion_id", "dermoscopic_lesion_id"])
+    )
+    if paired.empty:
+        raise ValueError(f"No paired clinical/dermoscopic lesions found under {input_dir}")
+    return paired
+
+
+def resolve_monet_columns(meta: pd.DataFrame) -> list[str]:
+    try:
+        from milk10k_dual_encoder.config import MONET_COLUMNS
+
+        configured = [column for column in MONET_COLUMNS if column in meta.columns]
+        if configured:
+            return configured
+    except Exception:
+        pass
+    return sorted(column for column in meta.columns if column.startswith("MONET_"))
+
+
+def lesion_split(df: pd.DataFrame, val_size: float, seed: int) -> tuple[pd.DataFrame, pd.DataFrame]:
+    lesion_df = df[["lesion_id", "label"]].drop_duplicates("lesion_id")
+    train_lesions, val_lesions = train_test_split(
+        lesion_df,
+        test_size=val_size,
+        stratify=lesion_df["label"],
+        random_state=seed,
+    )
+    return split_by_lesion_ids(df, train_lesions["lesion_id"], val_lesions["lesion_id"])
+
+
+def kfold_splits(df: pd.DataFrame, k_folds: int, seed: int) -> list[tuple[pd.DataFrame, pd.DataFrame]]:
+    if k_folds < 2:
+        raise ValueError("--k-folds must be 1 for single split or at least 2 for k-fold training.")
+
+    lesion_df = df[["lesion_id", "label"]].drop_duplicates("lesion_id").reset_index(drop=True)
+    min_class_count = int(lesion_df["label"].value_counts().min())
+    if k_folds > min_class_count:
+        raise ValueError(
+            f"--k-folds={k_folds} is larger than the smallest class count ({min_class_count}). "
+            "Use fewer folds or merge/remove ultra-rare classes."
+        )
+
+    splitter = StratifiedKFold(n_splits=k_folds, shuffle=True, random_state=seed)
+    splits = []
+    for train_idx, val_idx in splitter.split(lesion_df["lesion_id"], lesion_df["label"]):
+        train_lesions = lesion_df.iloc[train_idx]["lesion_id"]
+        val_lesions = lesion_df.iloc[val_idx]["lesion_id"]
+        splits.append(split_by_lesion_ids(df, train_lesions, val_lesions))
+    return splits
+
+
+def split_by_lesion_ids(
+    df: pd.DataFrame,
+    train_lesions: pd.Series,
+    val_lesions: pd.Series,
+) -> tuple[pd.DataFrame, pd.DataFrame]:
+    return (
+        df[df["lesion_id"].isin(train_lesions)].copy(),
+        df[df["lesion_id"].isin(val_lesions)].copy(),
+    )
+
+
+def fit_metadata_spec(train_df: pd.DataFrame) -> dict[str, Any]:
+    sex_values = sorted({"unknown"} | collect_string_values(train_df, "sex"))
+    site_values = sorted({"unknown"} | collect_string_values(train_df, "site"))
+    return {
+        "sex_values": sex_values,
+        "site_values": site_values,
+        "monet_columns": infer_paired_monet_columns(train_df),
+    }
+
+
+def collect_string_values(df: pd.DataFrame, field: str) -> set[str]:
+    values: set[str] = set()
+    for prefix in ("clinical", "dermoscopic"):
+        series = df[f"{prefix}_{field}"].fillna("unknown").astype(str).str.strip()
+        values.update(value if value else "unknown" for value in series.tolist())
+    return values
+
+
+def infer_paired_monet_columns(df: pd.DataFrame) -> list[str]:
+    clinical_prefix = "clinical_MONET_"
+    return sorted(
+        column.removeprefix("clinical_")
+        for column in df.columns
+        if column.startswith(clinical_prefix) and f"dermoscopic_{column.removeprefix('clinical_')}" in df.columns
+    )
+
+
+def metadata_vector(row: pd.Series, spec: dict[str, Any]) -> np.ndarray:
+    age = first_numeric(row, "age_approx")
+    skin_tone = first_numeric(row, "skin_tone_class")
+    sex = first_string(row, "sex")
+    site = first_string(row, "site")
+
+    values: list[float] = [
+        0.0 if age is None else float(age) / 100.0,
+        0.0 if skin_tone is None else float(skin_tone) / 6.0,
+    ]
+    values.extend(1.0 if sex == item else 0.0 for item in spec["sex_values"])
+    values.extend(1.0 if site == item else 0.0 for item in spec["site_values"])
+
+    for prefix in ("clinical", "dermoscopic"):
+        for column in spec.get("monet_columns", []):
+            value = pd.to_numeric(row.get(f"{prefix}_{column}"), errors="coerce")
+            values.append(0.0 if pd.isna(value) else float(value))
+
+    return np.asarray(values, dtype=np.float32)
+
+
+def first_numeric(row: pd.Series, field: str) -> float | None:
+    for prefix in ("clinical", "dermoscopic"):
+        value = pd.to_numeric(row.get(f"{prefix}_{field}"), errors="coerce")
+        if not pd.isna(value):
+            return float(value)
+    return None
+
+
+def first_string(row: pd.Series, field: str) -> str:
+    for prefix in ("clinical", "dermoscopic"):
+        value = row.get(f"{prefix}_{field}")
+        if pd.notna(value):
+            value = str(value).strip()
+            if value:
+                return value
+    return "unknown"
+
+
+def make_transforms(image_size: int):
+    normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+    train_transform = transforms.Compose(
+        [
+            transforms.Resize((image_size, image_size)),
+            transforms.RandomHorizontalFlip(),
+            transforms.RandomVerticalFlip(),
+            transforms.RandomRotation(20),
+            transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
+            transforms.ToTensor(),
+            normalize,
+        ]
+    )
+    eval_transform = transforms.Compose(
+        [
+            transforms.Resize((image_size, image_size)),
+            transforms.ToTensor(),
+            normalize,
+        ]
+    )
+    return train_transform, eval_transform
+
+
+def make_loaders(
+    train_df: pd.DataFrame,
+    val_df: pd.DataFrame,
+    label_to_idx: dict[str, int],
+    metadata_spec: dict[str, Any],
+    args: argparse.Namespace,
+) -> tuple[DataLoader, DataLoader]:
+    train_transform, eval_transform = make_transforms(args.image_size)
+    train_ds = PairedMilk10kMetadataDataset(train_df, label_to_idx, metadata_spec, train_transform)
+    val_ds = PairedMilk10kMetadataDataset(val_df, label_to_idx, metadata_spec, eval_transform)
+    common = dict(
+        batch_size=args.batch_size,
+        num_workers=args.num_workers,
+        pin_memory=torch.cuda.is_available(),
+        drop_last=False,
+    )
+    sampler = build_weighted_sampler(train_ds, args) if args.weighted_sampler else None
+    train_loader = DataLoader(train_ds, shuffle=sampler is None, sampler=sampler, **common)
+    val_loader = DataLoader(val_ds, shuffle=False, **common)
+    return train_loader, val_loader
+
+
+def build_weighted_sampler(
+    dataset: PairedMilk10kMetadataDataset,
+    args: argparse.Namespace,
+) -> WeightedRandomSampler:
+    labels = np.asarray(dataset.labels)
+    counts = np.bincount(labels)
+    if np.any(counts == 0):
+        raise ValueError("Cannot build weighted sampler because at least one class has zero training samples.")
+    class_weights = 1.0 / np.power(counts.astype(np.float64), args.sampler_power)
+    sample_weights = torch.as_tensor(class_weights[labels], dtype=torch.double)
+    generator = torch.Generator()
+    generator.manual_seed(args.seed)
+    return WeightedRandomSampler(sample_weights, num_samples=len(dataset), replacement=True, generator=generator)
+

milk10k_effb2_metadata/losses.py

@@ -0,0 +1,111 @@
+"""Classification losses for the EffB2 metadata trainer."""
+
+from __future__ import annotations
+
+import argparse
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+from sklearn.utils.class_weight import compute_class_weight
+from torch import nn
+
+
+class FocalLoss(nn.Module):
+    def __init__(self, weight: torch.Tensor | None = None, gamma: float = 2.0) -> None:
+        super().__init__()
+        self.weight = weight
+        self.gamma = gamma
+
+    def forward(self, logits: torch.Tensor, labels: torch.Tensor) -> torch.Tensor:
+        ce = F.cross_entropy(logits, labels, reduction="none")
+        pt = torch.exp(-ce)
+        loss = (1.0 - pt) ** self.gamma * ce
+        if self.weight is not None:
+            loss = loss * self.weight[labels]
+        return loss.mean()
+
+
+class MILKLongTailLoss(nn.Module):
+    """LDAM + balanced-softmax/logit adjustment + deferred effective-number alpha."""
+
+    def __init__(
+        self,
+        class_counts: torch.Tensor,
+        beta: float = 0.9999,
+        max_margin: float = 0.5,
+        logit_tau: float = 1.0,
+        deferred_start_epoch: int = 0,
+        alpha_max: float = 10.0,
+    ) -> None:
+        super().__init__()
+        counts = class_counts.float().clamp_min(1.0)
+        margins = 1.0 / torch.sqrt(torch.sqrt(counts))
+        margins = margins * (max_margin / margins.max().clamp_min(1e-12))
+        priors = counts / counts.sum()
+        alpha = effective_number_alpha(counts, beta)
+        alpha = alpha.clamp(max=alpha_max)
+        alpha = alpha * (counts.numel() / alpha.sum().clamp_min(1e-12))
+
+        self.register_buffer("margins", margins)
+        self.register_buffer("log_priors", priors.log())
+        self.register_buffer("alpha", alpha)
+        self.logit_tau = logit_tau
+        self.deferred_start_epoch = deferred_start_epoch
+        self.current_epoch = 0
+
+    def set_epoch(self, epoch: int) -> None:
+        self.current_epoch = epoch
+
+    def forward(self, logits: torch.Tensor, labels: torch.Tensor) -> torch.Tensor:
+        adjusted_logits = logits.clone()
+        rows = torch.arange(labels.size(0), device=labels.device)
+        adjusted_logits[rows, labels] = adjusted_logits[rows, labels] - self.margins[labels]
+        adjusted_logits = adjusted_logits + self.logit_tau * self.log_priors
+        loss = F.cross_entropy(adjusted_logits, labels, reduction="none")
+        if self.current_epoch >= self.deferred_start_epoch:
+            loss = loss * self.alpha[labels]
+        return loss.mean()
+
+
+def effective_number_alpha(counts: torch.Tensor, beta: float) -> torch.Tensor:
+    if beta <= 0.0:
+        return torch.ones_like(counts)
+    if beta >= 1.0:
+        raise ValueError("--lt-beta must be less than 1.0")
+    beta_tensor = torch.tensor(beta, dtype=counts.dtype, device=counts.device)
+    effective_num = 1.0 - torch.pow(beta_tensor, counts)
+    alpha = (1.0 - beta_tensor) / effective_num.clamp_min(1e-12)
+    return alpha
+
+
+def class_count_tensor(train_df: pd.DataFrame, label_to_idx: dict[str, int], device: torch.device) -> torch.Tensor:
+    y = np.array([label_to_idx[label] for label in train_df["label"]])
+    counts = np.bincount(y, minlength=len(label_to_idx))
+    if np.any(counts == 0):
+        missing = [label for label, idx in label_to_idx.items() if counts[idx] == 0]
+        raise ValueError(f"Cannot build loss because train split has zero samples for classes: {missing}")
+    return torch.tensor(counts, dtype=torch.float32, device=device)
+
+
+def build_loss(train_df: pd.DataFrame, label_to_idx: dict[str, int], args: argparse.Namespace, device: torch.device) -> nn.Module:
+    if args.loss == "milk_lt":
+        counts = class_count_tensor(train_df, label_to_idx, device)
+        return MILKLongTailLoss(
+            class_counts=counts,
+            beta=args.lt_beta,
+            max_margin=args.lt_max_margin,
+            logit_tau=args.lt_logit_tau,
+            deferred_start_epoch=args.lt_draw_start_epoch,
+            alpha_max=args.lt_alpha_max,
+        )
+
+    weight = None
+    if args.class_weight:
+        y = np.array([label_to_idx[label] for label in train_df["label"]])
+        weights = compute_class_weight(class_weight="balanced", classes=np.arange(len(label_to_idx)), y=y)
+        weight = torch.tensor(weights, dtype=torch.float32, device=device)
+    if args.loss == "focal":
+        return FocalLoss(weight=weight, gamma=args.focal_gamma)
+    return nn.CrossEntropyLoss(weight=weight)

milk10k_effb2_metadata/metrics.py

@@ -0,0 +1,144 @@
+"""Prediction and classification metric helpers."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+import torch
+from sklearn.metrics import (
+    accuracy_score,
+    balanced_accuracy_score,
+    classification_report,
+    confusion_matrix,
+    precision_recall_fscore_support,
+    roc_auc_score,
+)
+from sklearn.preprocessing import label_binarize
+from torch.utils.data import DataLoader
+from tqdm.auto import tqdm
+
+from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier
+
+
+def move_batch(batch: dict[str, torch.Tensor], device: torch.device) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+    clinical = batch["clinical"].to(device, non_blocking=True)
+    dermoscopic = batch["dermoscopic"].to(device, non_blocking=True)
+    metadata = batch["metadata"].to(device, non_blocking=True)
+    labels = batch["label"].to(device, non_blocking=True)
+    return clinical, dermoscopic, metadata, labels
+
+
+@torch.no_grad()
+def predict(model: DualEffB2MetadataClassifier, loader: DataLoader, device: torch.device) -> tuple[np.ndarray, np.ndarray]:
+    model.eval()
+    labels_all = []
+    probs_all = []
+    for batch in tqdm(loader, leave=False):
+        clinical, dermoscopic, metadata, labels = move_batch(batch, device)
+        logits = model(clinical, dermoscopic, metadata)
+        labels_all.append(labels.cpu().numpy())
+        probs_all.append(torch.softmax(logits, dim=1).cpu().numpy())
+    return np.concatenate(labels_all), np.concatenate(probs_all)
+
+
+def compute_metrics(y_true: np.ndarray, y_prob: np.ndarray, class_names: list[str]) -> tuple[dict[str, Any], pd.DataFrame, np.ndarray]:
+    y_pred = y_prob.argmax(axis=1)
+    labels = list(range(len(class_names)))
+    y_true_bin = label_binarize(y_true, classes=labels)
+    cm = confusion_matrix(y_true, y_pred, labels=labels)
+
+    precision_macro, recall_macro, f1_macro, _ = precision_recall_fscore_support(
+        y_true, y_pred, labels=labels, average="macro", zero_division=0
+    )
+    precision_weighted, recall_weighted, f1_weighted, _ = precision_recall_fscore_support(
+        y_true, y_pred, labels=labels, average="weighted", zero_division=0
+    )
+    precision_per_class, recall_per_class, f1_per_class, support_per_class = precision_recall_fscore_support(
+        y_true, y_pred, labels=labels, average=None, zero_division=0
+    )
+
+    total = cm.sum()
+    per_class_rows = []
+    for idx, class_name in enumerate(class_names):
+        tp = int(cm[idx, idx])
+        fn = int(cm[idx, :].sum() - tp)
+        fp = int(cm[:, idx].sum() - tp)
+        tn = int(total - tp - fn - fp)
+        try:
+            auc_ovr = float(roc_auc_score(y_true_bin[:, idx], y_prob[:, idx]))
+        except ValueError:
+            auc_ovr = None
+        per_class_rows.append(
+            {
+                "class": class_name,
+                "support": int(support_per_class[idx]),
+                "precision": float(precision_per_class[idx]),
+                "recall_sensitivity": float(recall_per_class[idx]),
+                "specificity": tn / (tn + fp) if (tn + fp) else 0.0,
+                "f1": float(f1_per_class[idx]),
+                "auc_ovr": auc_ovr,
+            }
+        )
+
+    metrics = {
+        "accuracy": float(accuracy_score(y_true, y_pred)),
+        "balanced_accuracy": float(balanced_accuracy_score(y_true, y_pred)),
+        "top2_accuracy": float(np.mean((np.argsort(y_prob, axis=1)[:, -min(2, len(class_names)) :] == y_true[:, None]).any(axis=1))),
+        "top3_accuracy": float(np.mean((np.argsort(y_prob, axis=1)[:, -min(3, len(class_names)) :] == y_true[:, None]).any(axis=1))),
+        "precision_macro": float(precision_macro),
+        "recall_macro": float(recall_macro),
+        "f1_macro": float(f1_macro),
+        "precision_weighted": float(precision_weighted),
+        "recall_weighted": float(recall_weighted),
+        "f1_weighted": float(f1_weighted),
+        "roc_auc_macro_ovr": safe_roc_auc(y_true_bin, y_prob, "macro"),
+        "roc_auc_weighted_ovr": safe_roc_auc(y_true_bin, y_prob, "weighted"),
+        "roc_auc_micro_ovr": safe_roc_auc(y_true_bin, y_prob, "micro"),
+        "specificity_macro": float(np.mean([row["specificity"] for row in per_class_rows])),
+        "per_class": per_class_rows,
+        "classification_report": classification_report(
+            y_true,
+            y_pred,
+            labels=labels,
+            target_names=class_names,
+            zero_division=0,
+            output_dict=True,
+        ),
+        "class_names": class_names,
+    }
+    return metrics, pd.DataFrame(per_class_rows), cm
+
+
+def safe_roc_auc(y_true_bin: np.ndarray, y_prob: np.ndarray, average: str | None) -> float | None:
+    try:
+        return float(roc_auc_score(y_true_bin, y_prob, average=average, multi_class="ovr"))
+    except ValueError:
+        return None
+
+
+def save_predictions(
+    val_df: pd.DataFrame,
+    y_true: np.ndarray,
+    y_prob: np.ndarray,
+    class_names: list[str],
+    output_dir: Path,
+) -> None:
+    y_pred = y_prob.argmax(axis=1)
+    prediction_df = pd.DataFrame(
+        {
+            "lesion_id": val_df["lesion_id"].tolist(),
+            "clinical_path": val_df["clinical_path"].tolist(),
+            "dermoscopic_path": val_df["dermoscopic_path"].tolist(),
+            "y_true": y_true,
+            "y_pred": y_pred,
+            "label_true": [class_names[idx] for idx in y_true],
+            "label_pred": [class_names[idx] for idx in y_pred],
+            "confidence": y_prob.max(axis=1),
+        }
+    )
+    probability_df = pd.DataFrame(y_prob, columns=[f"prob_{name}" for name in class_names])
+    pd.concat([prediction_df, probability_df], axis=1).to_csv(output_dir / "val_predictions.csv", index=False)
+

milk10k_effb2_metadata/models.py

@@ -0,0 +1,122 @@
+"""Model components for the dual EfficientNet-B2 metadata classifier."""
+
+from __future__ import annotations
+
+import timm
+import torch
+from torch import nn
+from torchvision.models import EfficientNet_B2_Weights, efficientnet_b2
+
+
+class ProjectionHead(nn.Module):
+    def __init__(self, in_dim: int, out_dim: int, dropout: float) -> None:
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.LayerNorm(in_dim),
+            nn.Dropout(dropout),
+            nn.Linear(in_dim, out_dim),
+            nn.GELU(),
+            nn.LayerNorm(out_dim),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.net(x)
+
+
+class MetadataHead(nn.Module):
+    def __init__(self, in_dim: int, out_dim: int, dropout: float) -> None:
+        super().__init__()
+        hidden_dim = max(out_dim * 2, 32)
+        self.net = nn.Sequential(
+            nn.LayerNorm(in_dim),
+            nn.Linear(in_dim, hidden_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden_dim, out_dim),
+            nn.GELU(),
+            nn.LayerNorm(out_dim),
+        )
+
+    def forward(self, metadata: torch.Tensor) -> torch.Tensor:
+        return self.net(metadata)
+
+
+class DualEffB2MetadataClassifier(nn.Module):
+    def __init__(
+        self,
+        num_classes: int,
+        metadata_input_dim: int,
+        branch_dim: int,
+        metadata_dim: int,
+        classifier_hidden_dim: int,
+        dropout: float,
+        imagenet_pretrained: bool,
+        clinical_backbone_backend: str,
+        dermoscopic_backbone_backend: str,
+    ) -> None:
+        super().__init__()
+        self.clinical_backbone_backend = clinical_backbone_backend
+        self.dermoscopic_backbone_backend = dermoscopic_backbone_backend
+        self.clinical_encoder, clinical_feature_dim = build_effb2_feature_encoder(
+            clinical_backbone_backend,
+            imagenet_pretrained,
+        )
+        self.dermoscopic_encoder, dermoscopic_feature_dim = build_effb2_feature_encoder(
+            dermoscopic_backbone_backend,
+            imagenet_pretrained,
+        )
+
+        self.clinical_head = ProjectionHead(clinical_feature_dim, branch_dim, dropout)
+        self.dermoscopic_head = ProjectionHead(dermoscopic_feature_dim, branch_dim, dropout)
+        self.metadata_head = MetadataHead(metadata_input_dim, metadata_dim, dropout)
+        fused_dim = branch_dim * 2 + metadata_dim
+        self.classifier = nn.Sequential(
+            nn.LayerNorm(fused_dim),
+            nn.Dropout(dropout),
+            nn.Linear(fused_dim, classifier_hidden_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(classifier_hidden_dim, num_classes),
+        )
+
+    def forward(
+        self,
+        clinical: torch.Tensor,
+        dermoscopic: torch.Tensor,
+        metadata: torch.Tensor,
+    ) -> torch.Tensor:
+        clinical_features = self.clinical_encoder(clinical)
+        dermoscopic_features = self.dermoscopic_encoder(dermoscopic)
+        clinical_repr = self.clinical_head(clinical_features)
+        dermoscopic_repr = self.dermoscopic_head(dermoscopic_features)
+        metadata_repr = self.metadata_head(metadata)
+        fused = torch.cat([clinical_repr, dermoscopic_repr, metadata_repr], dim=1)
+        return self.classifier(fused)
+
+
+def build_effb2_feature_encoder(backbone_backend: str, imagenet_pretrained: bool) -> tuple[nn.Module, int]:
+    if backbone_backend == "timm":
+        model = timm.create_model(
+            "efficientnet_b2",
+            pretrained=imagenet_pretrained,
+            num_classes=0,
+            global_pool="avg",
+        )
+        return model, int(model.num_features)
+
+    if backbone_backend == "torchvision":
+        weights = EfficientNet_B2_Weights.IMAGENET1K_V1 if imagenet_pretrained else None
+        model = efficientnet_b2(weights=weights)
+        feature_dim = int(model.classifier[1].in_features)
+        model.classifier = nn.Identity()
+        return model, feature_dim
+
+    raise ValueError(f"Unsupported backbone backend: {backbone_backend}")
+
+
+def set_encoder_trainable(model: DualEffB2MetadataClassifier, trainable: bool) -> None:
+    for param in model.clinical_encoder.parameters():
+        param.requires_grad = trainable
+    for param in model.dermoscopic_encoder.parameters():
+        param.requires_grad = trainable
+

milk10k_effb2_metadata/training.py

@@ -0,0 +1,502 @@
+"""Training orchestration for the EffB2 dual metadata classifier."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+import torch
+from sklearn.metrics import balanced_accuracy_score, precision_recall_fscore_support
+from torch import nn
+from torch.amp import GradScaler, autocast
+from torch.utils.data import DataLoader
+from tqdm.auto import tqdm
+
+from datasets import resolve_data_dir, set_seed
+from milk10k_effb2_metadata.checkpoints import load_encoder_checkpoint, resolve_backbone_backends
+from milk10k_effb2_metadata.data import (
+    fit_metadata_spec,
+    kfold_splits,
+    lesion_split,
+    load_paired_dataframe,
+    make_loaders,
+    metadata_vector,
+)
+from milk10k_effb2_metadata.losses import build_loss
+from milk10k_effb2_metadata.metrics import compute_metrics, move_batch, predict, save_predictions
+from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier, set_encoder_trainable
+
+
+def build_optimizer(model: DualEffB2MetadataClassifier, args: argparse.Namespace, encoders_trainable: bool) -> torch.optim.Optimizer:
+    head_params = []
+    encoder_params = []
+    for name, param in model.named_parameters():
+        if not param.requires_grad:
+            continue
+        if name.startswith(("clinical_encoder.", "dermoscopic_encoder.")):
+            encoder_params.append(param)
+        else:
+            head_params.append(param)
+
+    groups = [{"params": head_params, "lr": args.head_lr}]
+    if encoders_trainable and encoder_params:
+        groups.append({"params": encoder_params, "lr": args.encoder_lr})
+    return torch.optim.AdamW(groups, weight_decay=args.weight_decay)
+
+
+def run_epoch(
+    model: DualEffB2MetadataClassifier,
+    loader: DataLoader,
+    criterion: nn.Module,
+    device: torch.device,
+    optimizer: torch.optim.Optimizer | None = None,
+    scaler: GradScaler | None = None,
+    use_amp: bool = False,
+) -> dict[str, float]:
+    training = optimizer is not None
+    model.train(training)
+    total_loss = 0.0
+    correct = 0
+    top3_correct = 0
+    total = 0
+    preds_all = []
+    labels_all = []
+
+    for batch in tqdm(loader, leave=False):
+        clinical, dermoscopic, metadata, labels = move_batch(batch, device)
+        if training:
+            optimizer.zero_grad(set_to_none=True)
+
+        with torch.set_grad_enabled(training):
+            with autocast("cuda", enabled=use_amp):
+                logits = model(clinical, dermoscopic, metadata)
+                loss = criterion(logits, labels)
+            if training:
+                if scaler is not None and use_amp:
+                    scaler.scale(loss).backward()
+                    scaler.unscale_(optimizer)
+                    torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+                    scaler.step(optimizer)
+                    scaler.update()
+                else:
+                    loss.backward()
+                    torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+                    optimizer.step()
+
+        batch_size = labels.size(0)
+        total_loss += float(loss.detach().item()) * batch_size
+        correct += (logits.argmax(dim=1) == labels).sum().item()
+        topk = min(3, logits.size(1))
+        top3_correct += logits.topk(topk, dim=1).indices.eq(labels[:, None]).any(dim=1).sum().item()
+        total += batch_size
+        preds_all.append(logits.argmax(dim=1).detach().cpu().numpy())
+        labels_all.append(labels.detach().cpu().numpy())
+
+    y_pred = np.concatenate(preds_all) if preds_all else np.array([])
+    y_true = np.concatenate(labels_all) if labels_all else np.array([])
+
+    return {
+        "loss": total_loss / max(total, 1),
+        "accuracy": correct / max(total, 1),
+        "balanced_accuracy": float(balanced_accuracy_score(y_true, y_pred)) if total else 0.0,
+        "f1_macro": float(precision_recall_fscore_support(y_true, y_pred, average="macro", zero_division=0)[2]) if total else 0.0,
+        "top3_accuracy": top3_correct / max(total, 1),
+    }
+
+
+def save_checkpoint(
+    path: Path,
+    model: DualEffB2MetadataClassifier,
+    optimizer: torch.optim.Optimizer,
+    epoch: int,
+    phase: str,
+    best_val_loss: float,
+    class_names: list[str],
+    label_to_idx: dict[str, int],
+    metadata_spec: dict[str, Any],
+    args: argparse.Namespace,
+) -> None:
+    torch.save(
+        {
+            "epoch": epoch,
+            "phase": phase,
+            "model_state": model.state_dict(),
+            "optimizer_state": optimizer.state_dict(),
+            "best_val_loss": best_val_loss,
+            "class_names": class_names,
+            "label_to_idx": label_to_idx,
+            "metadata_spec": metadata_spec,
+            "args": json_safe(vars(args)),
+        },
+        path,
+    )
+
+
+def train_phase(
+    phase: str,
+    num_epochs: int,
+    start_epoch: int,
+    model: DualEffB2MetadataClassifier,
+    train_loader: DataLoader,
+    val_loader: DataLoader,
+    criterion: nn.Module,
+    device: torch.device,
+    args: argparse.Namespace,
+    class_names: list[str],
+    label_to_idx: dict[str, int],
+    metadata_spec: dict[str, Any],
+    output_dir: Path,
+    history: list[dict[str, Any]],
+    best_val_loss: float,
+) -> tuple[int, float]:
+    if num_epochs <= 0:
+        return start_epoch, best_val_loss
+
+    encoders_trainable = phase == "finetune"
+    set_encoder_trainable(model, encoders_trainable)
+    optimizer = build_optimizer(model, args, encoders_trainable)
+    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode="min", factor=0.2, patience=2)
+    scaler = GradScaler("cuda", enabled=args.amp and device.type == "cuda")
+    use_amp = args.amp and device.type == "cuda"
+    patience_count = 0
+
+    print(f"\nPhase: {phase}, epochs={num_epochs}, encoders_trainable={encoders_trainable}")
+    for local_epoch in range(1, num_epochs + 1):
+        epoch = start_epoch + local_epoch - 1
+        if hasattr(criterion, "set_epoch"):
+            criterion.set_epoch(epoch)
+        train_stats = run_epoch(model, train_loader, criterion, device, optimizer, scaler, use_amp)
+        val_stats = run_epoch(model, val_loader, criterion, device)
+        scheduler.step(val_stats["loss"])
+        row = {
+            "phase": phase,
+            "epoch": epoch,
+            **{f"train_{key}": value for key, value in train_stats.items()},
+            **{f"val_{key}": value for key, value in val_stats.items()},
+        }
+        history.append(row)
+        pd.DataFrame(history).to_csv(output_dir / "history.csv", index=False)
+        print(
+            f"{phase} epoch {epoch:03d}: "
+            f"train_loss={train_stats['loss']:.4f} val_loss={val_stats['loss']:.4f} "
+            f"train_bal_acc={train_stats['balanced_accuracy']:.4f} train_f1={train_stats['f1_macro']:.4f} "
+            f"val_acc={val_stats['accuracy']:.4f} val_bal_acc={val_stats['balanced_accuracy']:.4f} "
+            f"val_f1={val_stats['f1_macro']:.4f} val_top3={val_stats['top3_accuracy']:.4f}"
+        )
+
+        if val_stats["loss"] < best_val_loss:
+            best_val_loss = val_stats["loss"]
+            patience_count = 0
+            save_checkpoint(
+                output_dir / "best.pt",
+                model,
+                optimizer,
+                epoch,
+                phase,
+                best_val_loss,
+                class_names,
+                label_to_idx,
+                metadata_spec,
+                args,
+            )
+        else:
+            patience_count += 1
+            if patience_count >= args.patience:
+                print(f"Early stopping {phase} at epoch {epoch}")
+                break
+
+    return start_epoch + num_epochs, best_val_loss
+
+
+def build_model(
+    class_names: list[str],
+    metadata_dim: int,
+    args: argparse.Namespace,
+    device: torch.device,
+    clinical_backbone_backend: str,
+    dermoscopic_backbone_backend: str,
+) -> DualEffB2MetadataClassifier:
+    model = DualEffB2MetadataClassifier(
+        num_classes=len(class_names),
+        metadata_input_dim=metadata_dim,
+        branch_dim=args.branch_dim,
+        metadata_dim=args.metadata_dim,
+        classifier_hidden_dim=args.classifier_hidden_dim,
+        dropout=args.dropout,
+        imagenet_pretrained=args.imagenet_pretrained,
+        clinical_backbone_backend=clinical_backbone_backend,
+        dermoscopic_backbone_backend=dermoscopic_backbone_backend,
+    ).to(device)
+    load_encoder_checkpoint(args.clinical_checkpoint, model.clinical_encoder, "clinical", device)
+    load_encoder_checkpoint(args.dermoscopic_checkpoint, model.dermoscopic_encoder, "dermoscopic", device)
+    return model
+
+
+def save_run_config(
+    output_dir: Path,
+    args: argparse.Namespace,
+    class_names: list[str],
+    metadata_spec: dict[str, Any],
+    train_df: pd.DataFrame,
+    val_df: pd.DataFrame,
+    clinical_backbone_backend: str,
+    dermoscopic_backbone_backend: str,
+    fold: int | None = None,
+) -> None:
+    payload = {
+        "args": json_safe(vars(args)),
+        "class_names": class_names,
+        "metadata_spec": json_safe(metadata_spec),
+        "train_size": len(train_df),
+        "val_size": len(val_df),
+        "fold": fold,
+        "fusion": "concat(clinical_head, dermoscopic_head, metadata_head)",
+        "clinical_backbone": f"{clinical_backbone_backend} efficientnet_b2",
+        "dermoscopic_backbone": f"{dermoscopic_backbone_backend} efficientnet_b2",
+    }
+    with open(output_dir / "run_config.json", "w", encoding="utf-8") as f:
+        json.dump(payload, f, indent=2)
+
+
+def run_training_split(
+    df: pd.DataFrame,
+    train_df: pd.DataFrame,
+    val_df: pd.DataFrame,
+    class_names: list[str],
+    label_to_idx: dict[str, int],
+    args: argparse.Namespace,
+    device: torch.device,
+    clinical_backbone_backend: str,
+    dermoscopic_backbone_backend: str,
+    output_dir: Path,
+    fold: int | None = None,
+) -> dict[str, Any]:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    split_dir = output_dir / "splits"
+    split_dir.mkdir(exist_ok=True)
+    train_df.to_csv(split_dir / "train.csv", index=False)
+    val_df.to_csv(split_dir / "val.csv", index=False)
+
+    metadata_spec = fit_metadata_spec(train_df)
+    metadata_dim = len(metadata_vector(train_df.iloc[0], metadata_spec))
+    save_run_config(
+        output_dir,
+        args,
+        class_names,
+        metadata_spec,
+        train_df,
+        val_df,
+        clinical_backbone_backend,
+        dermoscopic_backbone_backend,
+        fold,
+    )
+
+    model = build_model(
+        class_names,
+        metadata_dim,
+        args,
+        device,
+        clinical_backbone_backend,
+        dermoscopic_backbone_backend,
+    )
+    train_loader, val_loader = make_loaders(train_df, val_df, label_to_idx, metadata_spec, args)
+    criterion = build_loss(train_df, label_to_idx, args, device)
+
+    print(f"Output dir: {output_dir}")
+    print(f"Device: {device}")
+    print(f"Classes: {class_names}")
+    print(f"Paired lesions: train={len(train_df)}, val={len(val_df)}, total={len(df)}")
+    print(f"Metadata input dim: {metadata_dim}")
+    print(f"MONET columns: {len(metadata_spec.get('monet_columns', []))}")
+    print(f"Loss: {args.loss}, class_weight={args.class_weight}, weighted_sampler={args.weighted_sampler}")
+    if args.loss == "milk_lt" and args.class_weight:
+        print("Note: --class-weight is ignored for --loss milk_lt because milk_lt uses effective-number alpha.")
+
+    history: list[dict[str, Any]] = []
+    epoch, best_val_loss = train_phase(
+        "freeze",
+        args.freeze_epochs,
+        1,
+        model,
+        train_loader,
+        val_loader,
+        criterion,
+        device,
+        args,
+        class_names,
+        label_to_idx,
+        metadata_spec,
+        output_dir,
+        history,
+        float("inf"),
+    )
+    epoch, best_val_loss = train_phase(
+        "finetune",
+        args.finetune_epochs,
+        epoch,
+        model,
+        train_loader,
+        val_loader,
+        criterion,
+        device,
+        args,
+        class_names,
+        label_to_idx,
+        metadata_spec,
+        output_dir,
+        history,
+        best_val_loss,
+    )
+
+    best_path = output_dir / "best.pt"
+    if best_path.exists():
+        checkpoint = torch.load(best_path, map_location=device, weights_only=False)
+        model.load_state_dict(checkpoint["model_state"])
+    y_true, y_prob = predict(model, val_loader, device)
+    metrics, per_class_df, cm = compute_metrics(y_true, y_prob, class_names)
+    metrics = {"best_val_loss": float(best_val_loss), **metrics}
+    with open(output_dir / "metrics.json", "w", encoding="utf-8") as f:
+        json.dump(json_safe(metrics), f, indent=2)
+    pd.DataFrame(cm, index=class_names, columns=class_names).to_csv(output_dir / "confusion_matrix.csv")
+    per_class_df.to_csv(output_dir / "per_class_metrics.csv", index=False)
+    save_predictions(val_df, y_true, y_prob, class_names, output_dir)
+    print(
+        f"Done: best_val_loss={best_val_loss:.4f}, "
+        f"val_acc={metrics['accuracy']:.4f}, balanced_acc={metrics['balanced_accuracy']:.4f}, "
+        f"f1_macro={metrics['f1_macro']:.4f}, top3={metrics['top3_accuracy']:.4f}, "
+        f"auc_macro={metrics['roc_auc_macro_ovr']}"
+    )
+    return metrics
+
+
+def train_single_run(
+    df: pd.DataFrame,
+    class_names: list[str],
+    label_to_idx: dict[str, int],
+    args: argparse.Namespace,
+    device: torch.device,
+    clinical_backbone_backend: str,
+    dermoscopic_backbone_backend: str,
+) -> dict[str, Any]:
+    train_df, val_df = lesion_split(df, args.val_size, args.seed)
+    return run_training_split(
+        df,
+        train_df,
+        val_df,
+        class_names,
+        label_to_idx,
+        args,
+        device,
+        clinical_backbone_backend,
+        dermoscopic_backbone_backend,
+        args.output_dir,
+    )
+
+
+def train_kfold(
+    df: pd.DataFrame,
+    class_names: list[str],
+    label_to_idx: dict[str, int],
+    args: argparse.Namespace,
+    device: torch.device,
+    clinical_backbone_backend: str,
+    dermoscopic_backbone_backend: str,
+) -> list[dict[str, Any]]:
+    fold_metrics = []
+    for fold_idx, (train_df, val_df) in enumerate(kfold_splits(df, args.k_folds, args.seed)):
+        print(f"\nK-fold {fold_idx + 1}/{args.k_folds}")
+        metrics = run_training_split(
+            df,
+            train_df,
+            val_df,
+            class_names,
+            label_to_idx,
+            args,
+            device,
+            clinical_backbone_backend,
+            dermoscopic_backbone_backend,
+            args.output_dir / f"fold_{fold_idx:02d}",
+            fold_idx,
+        )
+        fold_metrics.append({"fold": fold_idx, **metrics})
+    save_kfold_summary(fold_metrics, args.output_dir)
+    return fold_metrics
+
+
+def save_kfold_summary(fold_metrics: list[dict[str, Any]], output_dir: Path) -> None:
+    summary_keys = [
+        "best_val_loss",
+        "accuracy",
+        "balanced_accuracy",
+        "f1_macro",
+        "roc_auc_macro_ovr",
+        "top3_accuracy",
+    ]
+    rows = []
+    for metrics in fold_metrics:
+        rows.append({key: metrics.get(key) for key in ["fold", *summary_keys]})
+    summary_df = pd.DataFrame(rows)
+    summary_df.to_csv(output_dir / "kfold_summary.csv", index=False)
+
+    aggregate: dict[str, Any] = {"folds": json_safe(rows), "mean": {}, "std": {}}
+    for key in summary_keys:
+        values = pd.to_numeric(summary_df[key], errors="coerce").dropna()
+        aggregate["mean"][key] = None if values.empty else float(values.mean())
+        aggregate["std"][key] = None if values.empty else float(values.std(ddof=0))
+    with open(output_dir / "kfold_summary.json", "w", encoding="utf-8") as f:
+        json.dump(aggregate, f, indent=2)
+
+
+def json_safe(value):
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, dict):
+        return {key: json_safe(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [json_safe(item) for item in value]
+    if isinstance(value, np.ndarray):
+        return value.tolist()
+    if isinstance(value, np.generic):
+        return value.item()
+    return value
+
+
+def run(args: argparse.Namespace) -> None:
+    if args.k_folds < 1:
+        raise ValueError("--k-folds must be at least 1.")
+
+    set_seed(args.seed)
+    data_dir = resolve_data_dir(args.data_dir)
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+
+    df = load_paired_dataframe(data_dir)
+    class_names = sorted(df["label"].unique())
+    label_to_idx = {label: idx for idx, label in enumerate(class_names)}
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    clinical_backbone_backend, dermoscopic_backbone_backend = resolve_backbone_backends(args, device)
+
+    print(f"Data dir: {data_dir}")
+    if args.k_folds == 1:
+        train_single_run(
+            df,
+            class_names,
+            label_to_idx,
+            args,
+            device,
+            clinical_backbone_backend,
+            dermoscopic_backbone_backend,
+        )
+    else:
+        train_kfold(
+            df,
+            class_names,
+            label_to_idx,
+            args,
+            device,
+            clinical_backbone_backend,
+            dermoscopic_backbone_backend,
+        )