Upload train_milk10k_effb2_dual_metadata.py

train_milk10k_effb2_dual_metadata.py

@@ -1,870 +1,14 @@
 #!/usr/bin/env python3
-"""Train a MILK10k dual EfficientNet-B2 classifier with metadata fusion.
+"""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 timm
-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,
-        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 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("--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()
-
-
-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 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 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")
-
-
-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,
-    clinical_backbone_backend: str,
-    dermoscopic_backbone_backend: str,
-) -> 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)",
-        "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)
+from milk10k_effb2_metadata.cli import parse_args
 
 
 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))
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    clinical_backbone_backend, dermoscopic_backbone_backend = resolve_backbone_backends(args, device)
-
-    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,
-        clinical_backbone_backend,
-        dermoscopic_backbone_backend,
-    )
-
-    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)
-
-    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,
-    )
+    from milk10k_effb2_metadata.training import run
 
-    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}"
-    )
+    run(args)
 
 
 if __name__ == "__main__":