Upload 32 files

milk10k_effb2_metadata/MILK10K_EFFB2_METADATA_CLI.md

@@ -13,6 +13,28 @@ Base checkpoints:
 --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt
 ```
 
+## Code Map
+
+Training code is split by responsibility:
+
+```text
+training.py         Thin entry facade: normalize args, load dataframe, choose single run vs k-fold.
+runner.py           Full split runner: split CSVs, loaders, loss, train phases, final metrics/files.
+engine.py           Epoch/phase loop: run_epoch, train_phase, save best checkpoint.
+model_setup.py      Backend detection, model construction, resume checkpoint, optimizer param groups.
+training_utils.py   JSON-safe serialization, run_config.json, kfold_summary.csv/json.
+```
+
+Common places to edit:
+
+```text
+Add/adjust training flow     runner.py
+Change epoch behavior        engine.py
+Change model/optimizer setup model_setup.py
+Change output summaries      training_utils.py
+Change top-level CLI run     training.py
+```
+
 ## 1. Check CLI
 
 ```bash
@@ -28,6 +50,34 @@ python train_milk10k_effb2_dual_metadata.py \
   --output-dir milk10k_effb2_baseline
 ```
 
+## Metadata Fusion Options
+
+Keep the baseline concat fusion:
+
+```bash
+--metadata-fusion concat
+```
+
+Use metadata as channel gates while still concatenating metadata into the classifier:
+
+```bash
+python train_milk10k_effb2_dual_metadata.py \
+  --clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+  --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \
+  --metadata-fusion gated_concat \
+  --output-dir milk10k_effb2_gated_concat
+```
+
+Use metadata only for channel gating, without direct metadata concat:
+
+```bash
+python train_milk10k_effb2_dual_metadata.py \
+  --clinical-checkpoint best_effnetb2_ufes_clinical.pth \
+  --dermoscopic-checkpoint efficientnet_b2_best_dermoscopic.pt \
+  --metadata-fusion gated_only \
+  --output-dir milk10k_effb2_gated_only
+```
+
 ## 3. Class Weight Only
 
 ```bash

milk10k_effb2_metadata/cli.py

@@ -49,17 +49,29 @@ def parse_args() -> argparse.Namespace:
         "--metadata-lr",
         type=float,
         default=None,
-        help="Optional LR for metadata_head. Defaults to --head-lr.",
+        help="Optional LR for metadata_head and metadata gates. Defaults to --head-lr.",
+    )
+    parser.add_argument(
+        "--metadata-fusion",
+        choices=["concat", "gated_concat", "gated_only"],
+        default="concat",
+        help="Metadata fusion mode. concat keeps the baseline; gated modes use metadata for channel gating.",
+    )
+    parser.add_argument(
+        "--metadata-gate-hidden-dim",
+        type=int,
+        default=None,
+        help="Hidden dimension for metadata channel gates. Defaults to --metadata-dim.",
     )
     parser.add_argument(
         "--disable-metadata",
         action="store_true",
-        help="Ignore metadata values by feeding a zero metadata representation and freezing metadata_head.",
+        help="Ignore metadata values by feeding zero metadata representation and all-one metadata gates.",
     )
     parser.add_argument(
         "--freeze-metadata-head",
         action="store_true",
-        help="Freeze metadata_head parameters while still using its current output.",
+        help="Freeze metadata_head and metadata gate parameters while still using their current outputs.",
     )
     parser.add_argument("--weight-decay", type=float, default=1e-4)
     parser.add_argument("--val-size", type=float, default=0.20)

milk10k_effb2_metadata/engine.py

@@ -0,0 +1,193 @@
+"""Epoch and phase execution for metadata model training."""
+
+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 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 milk10k_effb2_metadata.metrics import move_batch
+from milk10k_effb2_metadata.model_setup import build_optimizer
+from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier, set_encoder_trainable
+from milk10k_effb2_metadata.training_utils import json_safe
+
+
+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_f1: 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_f1_macro": best_val_f1,
+            "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_f1: float,
+    skip_until_epoch: int = 1,
+) -> tuple[int, float]:
+    if num_epochs <= 0:
+        return start_epoch, best_val_f1
+
+    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="max", 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 epoch < skip_until_epoch:
+            print(f"Skipping already completed {phase} epoch {epoch:03d}")
+            continue
+        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["f1_macro"])
+        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["f1_macro"] > best_val_f1:
+            best_val_f1 = val_stats["f1_macro"]
+            patience_count = 0
+            save_checkpoint(
+                output_dir / "best.pt",
+                model,
+                optimizer,
+                epoch,
+                phase,
+                best_val_f1,
+                class_names,
+                label_to_idx,
+                metadata_spec,
+                args,
+            )
+            print(
+                f"Saved best checkpoint: phase={phase} epoch={epoch:03d} "
+                f"best_val_f1_macro={best_val_f1:.4f} path={output_dir / 'best.pt'}"
+            )
+        else:
+            patience_count += 1
+            if patience_count >= args.patience:
+                print(f"Early stopping {phase} at epoch {epoch}")
+                break
+
+    return epoch + 1, best_val_f1

milk10k_effb2_metadata/inference.py

@@ -151,6 +151,8 @@ def build_model_from_checkpoint(checkpoint: dict[str, Any], metadata_dim: int, d
         dermoscopic_backbone_backend=dermoscopic_backend,
         backbone=checkpoint_arg(checkpoint_args, "backbone", "efficientnet_b2"),
         disable_metadata=checkpoint_arg(checkpoint_args, "disable_metadata", False),
+        metadata_fusion=checkpoint_arg(checkpoint_args, "metadata_fusion", "concat"),
+        metadata_gate_hidden_dim=checkpoint_args.get("metadata_gate_hidden_dim"),
     ).to(device)
     model.load_state_dict(state)
     model.eval()

milk10k_effb2_metadata/model_setup.py

@@ -0,0 +1,155 @@
+"""Model, optimizer, and checkpoint setup for metadata training."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import torch
+
+from milk10k_effb2_metadata.checkpoints import (
+    infer_checkpoint_backend,
+    load_encoder_checkpoint,
+    resolve_backbone_backends,
+)
+from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier
+
+
+def infer_branch_backend_from_state(state: dict[str, torch.Tensor], branch_prefix: str) -> str:
+    keys = [key.removeprefix(branch_prefix) for key in state if key.startswith(branch_prefix)]
+    timm_prefixes = ("conv_stem.", "bn1.", "blocks.", "conv_head.", "bn2.", "stages.", "stem.")
+    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"
+    if any(key.startswith("layer") for key in keys):
+        return "timm"
+    raise RuntimeError(f"Cannot infer backend for resume checkpoint branch prefix {branch_prefix!r}.")
+
+
+def resolve_training_backbone_backends(args: argparse.Namespace, device: torch.device) -> tuple[str, str]:
+    if args.backbone_backend != "auto":
+        return args.backbone_backend, args.backbone_backend
+    if args.clinical_checkpoint is not None and args.dermoscopic_checkpoint is not None:
+        return resolve_backbone_backends(args, device)
+    if args.clinical_checkpoint is not None:
+        clinical_backend = infer_checkpoint_backend(args.clinical_checkpoint, device, "clinical")
+        print(
+            "Auto-detected clinical backbone backend: "
+            f"clinical={clinical_backend}, dermoscopic={clinical_backend} (ImageNet initialized)"
+        )
+        return clinical_backend, clinical_backend
+    if args.dermoscopic_checkpoint is not None:
+        dermoscopic_backend = infer_checkpoint_backend(args.dermoscopic_checkpoint, device, "dermoscopic")
+        print(
+            "Auto-detected dermoscopic backbone backend: "
+            f"clinical={dermoscopic_backend} (ImageNet initialized), dermoscopic={dermoscopic_backend}"
+        )
+        return dermoscopic_backend, dermoscopic_backend
+    if args.resume_checkpoint is None:
+        print("No branch checkpoints passed; using torchvision backbones initialized from ImageNet weights.")
+        return "torchvision", "torchvision"
+    checkpoint = torch.load(args.resume_checkpoint.expanduser().resolve(), map_location=device, weights_only=False)
+    state = checkpoint["model_state"]
+    clinical_backend = infer_branch_backend_from_state(state, "clinical_encoder.")
+    dermoscopic_backend = infer_branch_backend_from_state(state, "dermoscopic_encoder.")
+    checkpoint_args = checkpoint.get("args", {})
+    if checkpoint_args.get("backbone") and args.backbone == "efficientnet_b2":
+        args.backbone = checkpoint_args["backbone"]
+    print(f"Auto-detected resume backends: clinical={clinical_backend}, dermoscopic={dermoscopic_backend}")
+    return clinical_backend, dermoscopic_backend
+
+
+def build_optimizer(
+    model: DualEffB2MetadataClassifier,
+    args: argparse.Namespace,
+    encoders_trainable: bool,
+) -> torch.optim.Optimizer:
+    head_params = []
+    encoder_params = []
+    metadata_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)
+        elif name.startswith(("metadata_head.", "clinical_metadata_gate.", "dermoscopic_metadata_gate.")):
+            metadata_params.append(param)
+        else:
+            head_params.append(param)
+
+    groups = [{"params": head_params, "lr": args.head_lr}]
+    if metadata_params:
+        groups.append({"params": metadata_params, "lr": args.metadata_lr if args.metadata_lr is not None else 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 set_metadata_head_trainable(model: DualEffB2MetadataClassifier, trainable: bool) -> None:
+    for param in model.metadata_head.parameters():
+        param.requires_grad = trainable
+    for module_name in ("clinical_metadata_gate", "dermoscopic_metadata_gate"):
+        module = getattr(model, module_name, None)
+        if module is not None:
+            for param in module.parameters():
+                param.requires_grad = trainable
+
+
+def load_resume_checkpoint(
+    checkpoint_path: Path | None,
+    model: DualEffB2MetadataClassifier,
+    device: torch.device,
+) -> tuple[int, float, str | None]:
+    if checkpoint_path is None:
+        return 1, float("-inf"), None
+    checkpoint_path = checkpoint_path.expanduser().resolve()
+    if not checkpoint_path.exists():
+        raise FileNotFoundError(f"Resume checkpoint not found: {checkpoint_path}")
+    checkpoint = torch.load(checkpoint_path, map_location=device, weights_only=False)
+    model.load_state_dict(checkpoint["model_state"])
+    next_epoch = int(checkpoint.get("epoch", 0)) + 1
+    best_val_f1 = float(checkpoint.get("best_val_f1_macro", float("-inf")))
+    phase = checkpoint.get("phase")
+    print(
+        f"Resumed checkpoint: {checkpoint_path}, phase={phase}, "
+        f"last_epoch={next_epoch - 1}, best_val_f1_macro={best_val_f1:.4f}"
+    )
+    print("Optimizer is re-created from current CLI LR settings.")
+    return next_epoch, best_val_f1, str(phase) if phase is not None else None
+
+
+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,
+        backbone=args.backbone,
+        disable_metadata=args.disable_metadata,
+        metadata_fusion=args.metadata_fusion,
+        metadata_gate_hidden_dim=args.metadata_gate_hidden_dim,
+    ).to(device)
+    if args.resume_checkpoint is None:
+        if args.clinical_checkpoint is not None:
+            load_encoder_checkpoint(args.clinical_checkpoint, model.clinical_encoder, "clinical", device)
+        if args.dermoscopic_checkpoint is not None:
+            load_encoder_checkpoint(args.dermoscopic_checkpoint, model.dermoscopic_encoder, "dermoscopic", device)
+    if args.disable_metadata or args.freeze_metadata_head:
+        set_metadata_head_trainable(model, False)
+    return model

milk10k_effb2_metadata/models.py

@@ -4,8 +4,8 @@ from __future__ import annotations
 
 import timm
 import torch
+import torch.nn.functional as F
 from torch import nn
-from torchvision.models import EfficientNet_B2_Weights, efficientnet_b2
 
 
 class ProjectionHead(nn.Module):
@@ -41,6 +41,26 @@ class MetadataHead(nn.Module):
         return self.net(metadata)
 
 
+class MetadataChannelGate(nn.Module):
+    def __init__(self, metadata_input_dim: int, channel_dim: int, hidden_dim: int, dropout: float) -> None:
+        super().__init__()
+        self.norm = nn.LayerNorm(metadata_input_dim)
+        self.fc1 = nn.Linear(metadata_input_dim, hidden_dim)
+        self.act = nn.GELU()
+        self.dropout = nn.Dropout(dropout)
+        self.fc2 = nn.Linear(hidden_dim, channel_dim)
+        nn.init.zeros_(self.fc2.weight)
+        nn.init.constant_(self.fc2.bias, 2.0)
+
+    def forward(self, metadata: torch.Tensor) -> torch.Tensor:
+        gate = self.norm(metadata)
+        gate = self.fc1(gate)
+        gate = self.act(gate)
+        gate = self.dropout(gate)
+        gate = torch.sigmoid(self.fc2(gate))
+        return gate
+
+
 class DualEffB2MetadataClassifier(nn.Module):
     def __init__(
         self,
@@ -55,13 +75,18 @@ class DualEffB2MetadataClassifier(nn.Module):
         dermoscopic_backbone_backend: str,
         backbone: str = "efficientnet_b2",
         disable_metadata: bool = False,
+        metadata_fusion: str = "concat",
+        metadata_gate_hidden_dim: int | None = None,
     ) -> None:
         super().__init__()
+        if metadata_fusion not in ("concat", "gated_concat", "gated_only"):
+            raise ValueError(f"Unsupported metadata_fusion: {metadata_fusion}")
         self.clinical_backbone_backend = clinical_backbone_backend
         self.dermoscopic_backbone_backend = dermoscopic_backbone_backend
-        self.backbone = backbone
+        self.backbone = normalize_backbone_name(backbone)
         self.disable_metadata = disable_metadata
         self.metadata_dim = metadata_dim
+        self.metadata_fusion = metadata_fusion
         self.clinical_encoder, clinical_feature_dim = build_feature_encoder(
             backbone,
             clinical_backbone_backend,
@@ -76,7 +101,23 @@ class DualEffB2MetadataClassifier(nn.Module):
         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
+        if metadata_fusion in ("gated_concat", "gated_only"):
+            gate_hidden_dim = metadata_gate_hidden_dim if metadata_gate_hidden_dim is not None else metadata_dim
+            self.clinical_metadata_gate = MetadataChannelGate(
+                metadata_input_dim,
+                clinical_feature_dim,
+                gate_hidden_dim,
+                dropout,
+            )
+            self.dermoscopic_metadata_gate = MetadataChannelGate(
+                metadata_input_dim,
+                dermoscopic_feature_dim,
+                gate_hidden_dim,
+                dropout,
+            )
+        fused_dim = branch_dim * 2
+        if metadata_fusion != "gated_only":
+            fused_dim += metadata_dim
         self.classifier = nn.Sequential(
             nn.LayerNorm(fused_dim),
             nn.Dropout(dropout),
@@ -92,19 +133,54 @@ class DualEffB2MetadataClassifier(nn.Module):
         dermoscopic: torch.Tensor,
         metadata: torch.Tensor,
     ) -> torch.Tensor:
-        clinical_features = self.clinical_encoder(clinical)
-        dermoscopic_features = self.dermoscopic_encoder(dermoscopic)
+        if self.metadata_fusion in ("gated_concat", "gated_only"):
+            clinical_features = self.encode_with_metadata_gate(
+                self.clinical_encoder,
+                self.clinical_backbone_backend,
+                clinical,
+                metadata,
+                self.clinical_metadata_gate,
+            )
+            dermoscopic_features = self.encode_with_metadata_gate(
+                self.dermoscopic_encoder,
+                self.dermoscopic_backbone_backend,
+                dermoscopic,
+                metadata,
+                self.dermoscopic_metadata_gate,
+            )
+        else:
+            clinical_features = self.clinical_encoder(clinical)
+            dermoscopic_features = self.dermoscopic_encoder(dermoscopic)
         clinical_features = torch.flatten(clinical_features, 1)
         dermoscopic_features = torch.flatten(dermoscopic_features, 1)
         clinical_repr = self.clinical_head(clinical_features)
         dermoscopic_repr = self.dermoscopic_head(dermoscopic_features)
-        if self.disable_metadata:
-            metadata_repr = clinical_repr.new_zeros((clinical_repr.size(0), self.metadata_dim))
+        if self.metadata_fusion == "gated_only":
+            fused = torch.cat([clinical_repr, dermoscopic_repr], dim=1)
         else:
-            metadata_repr = self.metadata_head(metadata)
-        fused = torch.cat([clinical_repr, dermoscopic_repr, metadata_repr], dim=1)
+            if self.disable_metadata:
+                metadata_repr = clinical_repr.new_zeros((clinical_repr.size(0), self.metadata_dim))
+            else:
+                metadata_repr = self.metadata_head(metadata)
+            fused = torch.cat([clinical_repr, dermoscopic_repr, metadata_repr], dim=1)
         return self.classifier(fused)
 
+    def encode_with_metadata_gate(
+        self,
+        encoder: nn.Module,
+        backbone_backend: str,
+        images: torch.Tensor,
+        metadata: torch.Tensor,
+        gate_module: MetadataChannelGate,
+    ) -> torch.Tensor:
+        feature_map = extract_spatial_features(encoder, backbone_backend, self.backbone, images)
+        if self.disable_metadata:
+            gate = feature_map.new_ones((feature_map.size(0), feature_map.size(1)))
+        else:
+            gate = gate_module(metadata).to(device=feature_map.device, dtype=feature_map.dtype)
+        gated = feature_map * gate[:, :, None, None]
+        return F.adaptive_avg_pool2d(gated, 1)
+
 
 def normalize_backbone_name(name: str) -> str:
     name = name.lower().replace(" ", "").replace("_", "").replace("-", "")
@@ -119,6 +195,35 @@ def normalize_backbone_name(name: str) -> str:
     raise ValueError(f"Unknown backbone: {name}")
 
 
+def extract_spatial_features(encoder: nn.Module, backbone_backend: str, backbone: str, images: torch.Tensor) -> torch.Tensor:
+    if backbone_backend == "timm":
+        features = encoder.forward_features(images)
+        if isinstance(features, (tuple, list)):
+            features = features[-1]
+    elif backbone_backend == "torchvision":
+        if backbone in ("efficientnet_b2", "efficientnet_b1", "convnext_base"):
+            features = encoder.features(images)
+        elif backbone == "resnet50":
+            features = encoder.conv1(images)
+            features = encoder.bn1(features)
+            features = encoder.relu(features)
+            features = encoder.maxpool(features)
+            features = encoder.layer1(features)
+            features = encoder.layer2(features)
+            features = encoder.layer3(features)
+            features = encoder.layer4(features)
+        else:
+            raise ValueError(f"Unsupported torchvision backbone for gated fusion: {backbone}")
+    else:
+        raise ValueError(f"Unsupported backbone backend: {backbone_backend}")
+
+    if features.ndim != 4:
+        raise RuntimeError(
+            f"Expected spatial feature map [B, C, H, W] for gated fusion, got shape {tuple(features.shape)}"
+        )
+    return features
+
+
 def build_feature_encoder(backbone: str, backbone_backend: str, imagenet_pretrained: bool) -> tuple[nn.Module, int]:
     backbone = normalize_backbone_name(backbone)
     if backbone_backend == "timm":

milk10k_effb2_metadata/runner.py

@@ -0,0 +1,216 @@
+"""Single-split and k-fold training runners."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+import torch
+
+from milk10k_effb2_metadata.data import (
+    fit_metadata_spec,
+    kfold_splits,
+    lesion_split,
+    make_loaders,
+    metadata_vector,
+)
+from milk10k_effb2_metadata.engine import train_phase
+from milk10k_effb2_metadata.losses import build_loss
+from milk10k_effb2_metadata.metrics import compute_metrics, predict, save_predictions
+from milk10k_effb2_metadata.model_setup import build_model, load_resume_checkpoint
+from milk10k_effb2_metadata.training_utils import json_safe, save_kfold_summary, save_run_config
+
+
+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,
+    )
+    resume_epoch, resume_best_val_f1, resume_phase = load_resume_checkpoint(args.resume_checkpoint, model, 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"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"Metadata mode: disable_metadata={args.disable_metadata}, "
+        f"freeze_metadata_head={args.freeze_metadata_head}, metadata_lr={args.metadata_lr}, "
+        f"fusion={args.metadata_fusion}, gate_hidden_dim={args.metadata_gate_hidden_dim}"
+    )
+    print(f"Loss: {args.loss}, class_weight={args.class_weight}, weighted_sampler={args.weighted_sampler}")
+    if args.loss == "ldam" and args.class_weight:
+        print("Note: --class-weight is ignored for --loss ldam because LDAM+DRW uses effective-number alpha.")
+
+    history: list[dict[str, Any]] = []
+    history_path = output_dir / "history.csv"
+    if args.resume_checkpoint is not None and history_path.exists():
+        history = pd.read_csv(history_path).to_dict("records")
+    best_start = resume_best_val_f1 if args.resume_checkpoint is not None else float("-inf")
+    skip_freeze_until = resume_epoch if resume_phase == "freeze" else 1
+    if resume_phase == "finetune":
+        skip_freeze_until = args.freeze_epochs + 1
+    skip_finetune_until = resume_epoch if resume_phase == "finetune" else 1
+    epoch, best_val_f1 = 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,
+        best_start,
+        skip_freeze_until,
+    )
+    epoch, best_val_f1 = 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_f1,
+        skip_finetune_until,
+    )
+
+    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_f1_macro": float(best_val_f1), **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_f1_macro={best_val_f1:.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]:
+    if args.synthetic_train_only:
+        synthetic_mask = df["lesion_id"].astype(str).str.contains("__sdpair_", regex=False)
+        real_df = df[~synthetic_mask].copy()
+        synthetic_df = df[synthetic_mask].copy()
+        train_df, val_df = lesion_split(real_df, args.val_size, args.seed)
+        train_df = pd.concat([train_df, synthetic_df], ignore_index=True, sort=False)
+        print(
+            f"Synthetic train-only split: real_train={len(train_df) - len(synthetic_df)}, "
+            f"synthetic_train={len(synthetic_df)}, val_real={len(val_df)}"
+        )
+    else:
+        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

milk10k_effb2_metadata/training.py

@@ -1,595 +1,21 @@
-"""Training orchestration for the EffB2 dual metadata classifier."""
+"""Training orchestration facade 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 milk10k_effb2_metadata.training_utils import json_safe
 
-from datasets import resolve_data_dir, set_seed
-from milk10k_effb2_metadata.checkpoints import infer_checkpoint_backend, 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 run(args: argparse.Namespace) -> None:
+    import torch
 
-def infer_branch_backend_from_state(state: dict[str, torch.Tensor], branch_prefix: str) -> str:
-    keys = [key.removeprefix(branch_prefix) for key in state if key.startswith(branch_prefix)]
-    timm_prefixes = ("conv_stem.", "bn1.", "blocks.", "conv_head.", "bn2.", "stages.", "stem.")
-    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"
-    if any(key.startswith("layer") for key in keys):
-        return "timm"
-    raise RuntimeError(f"Cannot infer backend for resume checkpoint branch prefix {branch_prefix!r}.")
-
-
-def resolve_training_backbone_backends(args: argparse.Namespace, device: torch.device) -> tuple[str, str]:
-    if args.backbone_backend != "auto":
-        return args.backbone_backend, args.backbone_backend
-    if args.clinical_checkpoint is not None and args.dermoscopic_checkpoint is not None:
-        return resolve_backbone_backends(args, device)
-    if args.clinical_checkpoint is not None:
-        clinical_backend = infer_checkpoint_backend(args.clinical_checkpoint, device, "clinical")
-        print(
-            "Auto-detected clinical backbone backend: "
-            f"clinical={clinical_backend}, dermoscopic={clinical_backend} (ImageNet initialized)"
-        )
-        return clinical_backend, clinical_backend
-    if args.dermoscopic_checkpoint is not None:
-        dermoscopic_backend = infer_checkpoint_backend(args.dermoscopic_checkpoint, device, "dermoscopic")
-        print(
-            "Auto-detected dermoscopic backbone backend: "
-            f"clinical={dermoscopic_backend} (ImageNet initialized), dermoscopic={dermoscopic_backend}"
-        )
-        return dermoscopic_backend, dermoscopic_backend
-    if args.resume_checkpoint is None:
-        print("No branch checkpoints passed; using torchvision backbones initialized from ImageNet weights.")
-        return "torchvision", "torchvision"
-    checkpoint = torch.load(args.resume_checkpoint.expanduser().resolve(), map_location=device, weights_only=False)
-    state = checkpoint["model_state"]
-    clinical_backend = infer_branch_backend_from_state(state, "clinical_encoder.")
-    dermoscopic_backend = infer_branch_backend_from_state(state, "dermoscopic_encoder.")
-    checkpoint_args = checkpoint.get("args", {})
-    if checkpoint_args.get("backbone") and args.backbone == "efficientnet_b2":
-        args.backbone = checkpoint_args["backbone"]
-    print(f"Auto-detected resume backends: clinical={clinical_backend}, dermoscopic={dermoscopic_backend}")
-    return clinical_backend, dermoscopic_backend
-
-
-def build_optimizer(model: DualEffB2MetadataClassifier, args: argparse.Namespace, encoders_trainable: bool) -> torch.optim.Optimizer:
-    head_params = []
-    encoder_params = []
-    metadata_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)
-        elif name.startswith("metadata_head."):
-            metadata_params.append(param)
-        else:
-            head_params.append(param)
-
-    groups = [{"params": head_params, "lr": args.head_lr}]
-    if metadata_params:
-        groups.append({"params": metadata_params, "lr": args.metadata_lr if args.metadata_lr is not None else 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 set_metadata_head_trainable(model: DualEffB2MetadataClassifier, trainable: bool) -> None:
-    for param in model.metadata_head.parameters():
-        param.requires_grad = trainable
-
-
-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_f1: 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_f1_macro": best_val_f1,
-            "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_f1: float,
-    skip_until_epoch: int = 1,
-) -> tuple[int, float]:
-    if num_epochs <= 0:
-        return start_epoch, best_val_f1
-
-    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="max", 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 epoch < skip_until_epoch:
-            print(f"Skipping already completed {phase} epoch {epoch:03d}")
-            continue
-        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["f1_macro"])
-        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["f1_macro"] > best_val_f1:
-            best_val_f1 = val_stats["f1_macro"]
-            patience_count = 0
-            save_checkpoint(
-                output_dir / "best.pt",
-                model,
-                optimizer,
-                epoch,
-                phase,
-                best_val_f1,
-                class_names,
-                label_to_idx,
-                metadata_spec,
-                args,
-            )
-            print(
-                f"Saved best checkpoint: phase={phase} epoch={epoch:03d} "
-                f"best_val_f1_macro={best_val_f1:.4f} path={output_dir / 'best.pt'}"
-            )
-        else:
-            patience_count += 1
-            if patience_count >= args.patience:
-                print(f"Early stopping {phase} at epoch {epoch}")
-                break
-
-    return epoch + 1, best_val_f1
-
-
-def load_resume_checkpoint(
-    checkpoint_path: Path | None,
-    model: DualEffB2MetadataClassifier,
-    device: torch.device,
-) -> tuple[int, float, str | None]:
-    if checkpoint_path is None:
-        return 1, float("-inf"), None
-    checkpoint_path = checkpoint_path.expanduser().resolve()
-    if not checkpoint_path.exists():
-        raise FileNotFoundError(f"Resume checkpoint not found: {checkpoint_path}")
-    checkpoint = torch.load(checkpoint_path, map_location=device, weights_only=False)
-    model.load_state_dict(checkpoint["model_state"])
-    next_epoch = int(checkpoint.get("epoch", 0)) + 1
-    best_val_f1 = float(checkpoint.get("best_val_f1_macro", float("-inf")))
-    phase = checkpoint.get("phase")
-    print(
-        f"Resumed checkpoint: {checkpoint_path}, phase={phase}, "
-        f"last_epoch={next_epoch - 1}, best_val_f1_macro={best_val_f1:.4f}"
-    )
-    print("Optimizer is re-created from current CLI LR settings.")
-    return next_epoch, best_val_f1, str(phase) if phase is not None else None
-
-
-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,
-        backbone=args.backbone,
-        disable_metadata=args.disable_metadata,
-    ).to(device)
-    if args.resume_checkpoint is None:
-        if args.clinical_checkpoint is not None:
-            load_encoder_checkpoint(args.clinical_checkpoint, model.clinical_encoder, "clinical", device)
-        if args.dermoscopic_checkpoint is not None:
-            load_encoder_checkpoint(args.dermoscopic_checkpoint, model.dermoscopic_encoder, "dermoscopic", device)
-    if args.disable_metadata or args.freeze_metadata_head:
-        set_metadata_head_trainable(model, False)
-    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)"
-        if not args.disable_metadata
-        else "concat(clinical_head, dermoscopic_head, zero_metadata_repr)",
-        "clinical_backbone": f"{clinical_backbone_backend} {args.backbone}",
-        "dermoscopic_backbone": f"{dermoscopic_backbone_backend} {args.backbone}",
-    }
-    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,
-    )
-    resume_epoch, resume_best_val_f1, resume_phase = load_resume_checkpoint(args.resume_checkpoint, model, 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"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"Metadata mode: disable_metadata={args.disable_metadata}, "
-        f"freeze_metadata_head={args.freeze_metadata_head}, metadata_lr={args.metadata_lr}"
-    )
-    print(f"Loss: {args.loss}, class_weight={args.class_weight}, weighted_sampler={args.weighted_sampler}")
-    if args.loss == "ldam" and args.class_weight:
-        print("Note: --class-weight is ignored for --loss ldam because LDAM+DRW uses effective-number alpha.")
-
-    history: list[dict[str, Any]] = []
-    history_path = output_dir / "history.csv"
-    if args.resume_checkpoint is not None and history_path.exists():
-        history = pd.read_csv(history_path).to_dict("records")
-    best_start = resume_best_val_f1 if args.resume_checkpoint is not None else float("-inf")
-    skip_freeze_until = resume_epoch if resume_phase == "freeze" else 1
-    if resume_phase == "finetune":
-        skip_freeze_until = args.freeze_epochs + 1
-    skip_finetune_until = resume_epoch if resume_phase == "finetune" else 1
-    epoch, best_val_f1 = 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,
-        best_start,
-        skip_freeze_until,
-    )
-    epoch, best_val_f1 = 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_f1,
-        skip_finetune_until,
-    )
-
-    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_f1_macro": float(best_val_f1), **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_f1_macro={best_val_f1:.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]:
-    if args.synthetic_train_only:
-        synthetic_mask = df["lesion_id"].astype(str).str.contains("__sdpair_", regex=False)
-        real_df = df[~synthetic_mask].copy()
-        synthetic_df = df[synthetic_mask].copy()
-        train_df, val_df = lesion_split(real_df, args.val_size, args.seed)
-        train_df = pd.concat([train_df, synthetic_df], ignore_index=True, sort=False)
-        print(
-            f"Synthetic train-only split: real_train={len(train_df) - len(synthetic_df)}, "
-            f"synthetic_train={len(synthetic_df)}, val_real={len(val_df)}"
-        )
-    else:
-        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_f1_macro",
-        "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
-
+    from datasets import resolve_data_dir, set_seed
+    from milk10k_effb2_metadata.data import load_paired_dataframe
+    from milk10k_effb2_metadata.model_setup import resolve_training_backbone_backends
+    from milk10k_effb2_metadata.models import normalize_backbone_name
+    from milk10k_effb2_metadata.runner import train_kfold, train_single_run
 
-def run(args: argparse.Namespace) -> None:
     if args.k_folds < 1:
         raise ValueError("--k-folds must be at least 1.")
 
@@ -597,8 +23,9 @@ def run(args: argparse.Namespace) -> None:
     data_dir = resolve_data_dir(args.data_dir)
     args.output_dir.mkdir(parents=True, exist_ok=True)
 
-    from milk10k_effb2_metadata.models import normalize_backbone_name
     args.backbone = normalize_backbone_name(args.backbone)
+    if args.metadata_gate_hidden_dim is None:
+        args.metadata_gate_hidden_dim = args.metadata_dim
     if args.resume_checkpoint is None and args.clinical_checkpoint is None and args.dermoscopic_checkpoint is None:
         args.imagenet_pretrained = True
     if args.image_size is None:

milk10k_effb2_metadata/training_utils.py

@@ -0,0 +1,81 @@
+"""Shared training serialization and reporting helpers."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+try:
+    import numpy as np
+except ModuleNotFoundError:  # pragma: no cover - keeps json_safe importable in minimal CLI environments.
+    np = None
+
+
+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:
+    import pandas as pd
+
+    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": args.metadata_fusion,
+        "clinical_backbone": f"{clinical_backbone_backend} {args.backbone}",
+        "dermoscopic_backbone": f"{dermoscopic_backbone_backend} {args.backbone}",
+    }
+    with open(output_dir / "run_config.json", "w", encoding="utf-8") as f:
+        json.dump(payload, f, indent=2)
+
+
+def save_kfold_summary(fold_metrics: list[dict[str, Any]], output_dir: Path) -> None:
+    import pandas as pd
+
+    summary_keys = [
+        "best_val_f1_macro",
+        "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 np is not None and isinstance(value, np.ndarray):
+        return value.tolist()
+    if np is not None and isinstance(value, np.generic):
+        return value.item()
+    return value