Upload 2 files

datasets.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""
+MILK10k dataset utilities shared by training scripts.
+
+Keep dataframe construction and torch Dataset classes here; training scripts
+should build transforms/loaders and own model/training logic.
+"""
+
+from __future__ import annotations
+
+import os
+import random
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+from PIL import Image, ImageFile
+from sklearn.model_selection import train_test_split
+from torch.utils.data import Dataset
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+REQUIRED_DATA_FILES = (
+    "MILK10k_Training_GroundTruth.csv",
+    "MILK10k_Training_Metadata.csv",
+    "MILK10k_Training_Input",
+)
+
+LABEL_COLUMNS = [
+    "AKIEC",
+    "BCC",
+    "BEN_OTH",
+    "BKL",
+    "DF",
+    "INF",
+    "MAL_OTH",
+    "MEL",
+    "NV",
+    "SCCKA",
+    "VASC",
+]
+
+
+class Milk10kDataset(Dataset):
+    def __init__(self, df: pd.DataFrame, label_to_idx: dict[str, int], transform=None) -> None:
+        self.paths = df["path"].tolist()
+        self.labels = [label_to_idx[label] for label in df["label"].tolist()]
+        self.transform = transform
+
+    def __len__(self) -> int:
+        return len(self.paths)
+
+    def __getitem__(self, idx: int) -> tuple[torch.Tensor, int]:
+        with Image.open(self.paths[idx]) as img:
+            img = img.convert("RGB")
+        if self.transform is not None:
+            img = self.transform(img)
+        return img, self.labels[idx]
+
+
+class PairedMilk10kDataset(Dataset):
+    def __init__(self, df: pd.DataFrame, label_to_idx: dict[str, int], transform=None) -> None:
+        self.clinical_paths = df["clinical_path"].tolist()
+        self.dermoscopic_paths = df["dermoscopic_path"].tolist()
+        self.labels = [label_to_idx[label] for label in df["label"].tolist()]
+        self.transform = transform
+
+    def __len__(self) -> int:
+        return len(self.labels)
+
+    def _load_image(self, path: str) -> torch.Tensor:
+        with Image.open(path) as img:
+            img = img.convert("RGB")
+        if self.transform is not None:
+            img = self.transform(img)
+        return img
+
+    def __getitem__(self, idx: int) -> tuple[torch.Tensor, int]:
+        clinical = self._load_image(self.clinical_paths[idx])
+        dermoscopic = self._load_image(self.dermoscopic_paths[idx])
+        return torch.stack([clinical, dermoscopic], dim=0), self.labels[idx]
+
+
+def set_seed(seed: int) -> None:
+    os.environ["PYTHONHASHSEED"] = str(seed)
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.benchmark = True
+
+
+def normalize_image_type(image_type: str) -> str:
+    if image_type == "clinical: close-up":
+        return "clinical_close_up"
+    return image_type.replace(" ", "_").replace(":", "").replace("-", "_")
+
+
+def has_milk10k_files(path: Path) -> bool:
+    return all((path / name).exists() for name in REQUIRED_DATA_FILES)
+
+
+def resolve_data_dir(data_dir: Path | None) -> Path:
+    if data_dir is not None:
+        data_dir = data_dir.expanduser().resolve()
+        if not has_milk10k_files(data_dir):
+            expected = ", ".join(REQUIRED_DATA_FILES)
+            raise FileNotFoundError(f"--data-dir={data_dir} does not contain required MILK10k files: {expected}")
+        return data_dir
+
+    candidates = [Path.cwd()]
+    kaggle_input = Path("/kaggle/input")
+    if kaggle_input.exists():
+        candidates.extend(path.parent for path in kaggle_input.rglob("MILK10k_Training_GroundTruth.csv"))
+
+    seen = set()
+    for candidate in candidates:
+        candidate = candidate.resolve()
+        if candidate in seen:
+            continue
+        seen.add(candidate)
+        if has_milk10k_files(candidate):
+            return candidate
+
+    expected = ", ".join(REQUIRED_DATA_FILES)
+    raise FileNotFoundError(
+        f"Could not auto-detect MILK10k data dir. Pass --data-dir PATH containing: {expected}"
+    )
+
+
+def load_dataframe(data_dir: Path, image_type: str) -> 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")
+
+    gt["label"] = gt[LABEL_COLUMNS].idxmax(axis=1)
+    df = meta.merge(gt[["lesion_id", "label"]], on="lesion_id", how="inner")
+    df["image_type_norm"] = df["image_type"].map(normalize_image_type)
+
+    if image_type != "all":
+        df = df[df["image_type_norm"] == image_type].copy()
+
+    df["path"] = df.apply(lambda r: input_dir / r["lesion_id"] / f"{r['isic_id']}.jpg", axis=1)
+    df = df[df["path"].map(lambda p: p.exists())].copy()
+    df["path"] = df["path"].map(str)
+
+    if df.empty:
+        raise ValueError(f"No images found for image_type={image_type!r} under {input_dir}")
+    return df[["path", "label", "lesion_id", "isic_id", "image_type_norm"]]
+
+
+def to_paired_lesion_dataframe(df: pd.DataFrame) -> pd.DataFrame:
+    clinical = (
+        df[df["image_type_norm"] == "clinical_close_up"][["lesion_id", "path"]]
+        .rename(columns={"path": "clinical_path"})
+        .drop_duplicates("lesion_id")
+    )
+    dermoscopic = (
+        df[df["image_type_norm"] == "dermoscopic"][["lesion_id", "path"]]
+        .rename(columns={"path": "dermoscopic_path"})
+        .drop_duplicates("lesion_id")
+    )
+    labels = df[["lesion_id", "label"]].drop_duplicates("lesion_id")
+    paired = labels.merge(clinical, on="lesion_id", how="inner").merge(dermoscopic, on="lesion_id", how="inner")
+    if paired.empty:
+        raise ValueError("No paired clinical/dermoscopic lesions found.")
+    return paired[["lesion_id", "label", "clinical_path", "dermoscopic_path"]]
+
+
+def lesion_level_train_val_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,
+    )
+
+    train_df = df[df["lesion_id"].isin(train_lesions["lesion_id"])].copy()
+    val_df = df[df["lesion_id"].isin(val_lesions["lesion_id"])].copy()
+    return train_df, val_df

train_milk10k_effb2_dual_metadata.py

@@ -0,0 +1,793 @@
+#!/usr/bin/env python3
+"""Train a MILK10k dual EfficientNet-B2 classifier with metadata fusion.
+
+This script is intentionally separate from the architecture benchmark package.
+It treats clinical and dermoscopic encoders as different feature spaces:
+each branch gets its own projection head, tabular metadata gets its own head,
+and classification uses the concatenated branch representations.
+"""
+
+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 PIL import Image, ImageFile
+from sklearn.metrics import (
+    accuracy_score,
+    balanced_accuracy_score,
+    classification_report,
+    confusion_matrix,
+    precision_recall_fscore_support,
+    roc_auc_score,
+)
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import label_binarize
+from sklearn.utils.class_weight import compute_class_weight
+from torch import nn
+from torch.amp import GradScaler, autocast
+from torch.utils.data import DataLoader, Dataset
+from torchvision import transforms
+from torchvision.models import EfficientNet_B2_Weights, efficientnet_b2
+from tqdm.auto import tqdm
+
+from datasets import LABEL_COLUMNS, normalize_image_type, resolve_data_dir, set_seed
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+
+METADATA_COLUMNS = ("age_approx", "sex", "skin_tone_class", "site")
+CHECKPOINT_STATE_KEYS = ("model_state", "model_state_dict", "state_dict")
+PREFIXES_TO_STRIP = ("module.", "model.", "_orig_mod.")
+
+
+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),
+        }
+
+
+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,
+    ) -> None:
+        super().__init__()
+        self.clinical_encoder, feature_dim = build_effb2_feature_encoder(imagenet_pretrained)
+        self.dermoscopic_encoder, derm_feature_dim = build_effb2_feature_encoder(imagenet_pretrained)
+        if feature_dim != derm_feature_dim:
+            raise RuntimeError(f"EfficientNet-B2 feature dims differ: {feature_dim} vs {derm_feature_dim}")
+
+        self.clinical_head = ProjectionHead(feature_dim, branch_dim, dropout)
+        self.dermoscopic_head = ProjectionHead(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 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=4)
+    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("--amp", action="store_true")
+    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()
+
+
+def build_effb2_feature_encoder(imagenet_pretrained: bool) -> tuple[nn.Module, int]:
+    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
+
+
+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")
+
+    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]
+    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 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 (
+        df[df["lesion_id"].isin(train_lesions["lesion_id"])].copy(),
+        df[df["lesion_id"].isin(val_lesions["lesion_id"])].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}
+
+
+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 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"])
+    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,
+    )
+    return DataLoader(train_ds, shuffle=True, **common), DataLoader(val_ds, shuffle=False, **common)
+
+
+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 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 load_encoder_checkpoint(path: Path, encoder: nn.Module, branch_name: str, device: torch.device) -> None:
+    if not path.exists():
+        raise FileNotFoundError(f"{branch_name} checkpoint not found: {path}")
+    try:
+        checkpoint = torch.load(path, map_location=device, weights_only=False)
+    except TypeError:
+        checkpoint = torch.load(path, map_location=device)
+
+    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")
+
+
+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
+
+
+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 build_loss(train_df: pd.DataFrame, label_to_idx: dict[str, int], args: argparse.Namespace, device: torch.device) -> nn.Module:
+    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)
+    return nn.CrossEntropyLoss(weight=weight)
+
+
+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
+
+
+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
+
+    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
+
+    return {
+        "loss": total_loss / max(total, 1),
+        "accuracy": correct / max(total, 1),
+        "top3_accuracy": top3_correct / max(total, 1),
+    }
+
+
+@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"),
+        "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_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": {key: str(value) if isinstance(value, Path) else value for key, value in vars(args).items()},
+        },
+        path,
+    )
+
+
+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)
+
+
+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
+        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"val_acc={val_stats['accuracy']:.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 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,
+) -> None:
+    payload = {
+        "args": {key: str(value) if isinstance(value, Path) else value for key, value in vars(args).items()},
+        "class_names": class_names,
+        "metadata_spec": metadata_spec,
+        "train_size": len(train_df),
+        "val_size": len(val_df),
+        "fusion": "concat(clinical_head, dermoscopic_head, metadata_head)",
+        "backbone": "torchvision efficientnet_b2",
+    }
+    with open(output_dir / "run_config.json", "w", encoding="utf-8") as f:
+        json.dump(payload, f, indent=2)
+
+
+def main() -> None:
+    args = parse_args()
+    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)}
+    train_df, val_df = lesion_split(df, args.val_size, args.seed)
+    metadata_spec = fit_metadata_spec(train_df)
+    metadata_dim = len(metadata_vector(train_df.iloc[0], metadata_spec))
+
+    split_dir = args.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)
+    save_run_config(args.output_dir, args, class_names, metadata_spec, train_df, val_df)
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    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,
+    ).to(device)
+    load_encoder_checkpoint(args.clinical_checkpoint, model.clinical_encoder, "clinical", device)
+    load_encoder_checkpoint(args.dermoscopic_checkpoint, model.dermoscopic_encoder, "dermoscopic", device)
+
+    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"Data dir: {data_dir}")
+    print(f"Output dir: {args.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}")
+
+    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,
+        args.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,
+        args.output_dir,
+        history,
+        best_val_loss,
+    )
+
+    best_path = args.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(args.output_dir / "metrics.json", "w", encoding="utf-8") as f:
+        json.dump(metrics, f, indent=2)
+    pd.DataFrame(cm, index=class_names, columns=class_names).to_csv(args.output_dir / "confusion_matrix.csv")
+    per_class_df.to_csv(args.output_dir / "per_class_metrics.csv", index=False)
+    save_predictions(val_df, y_true, y_prob, class_names, args.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}"
+    )
+
+
+if __name__ == "__main__":
+    main()