Upload 171 files

milk10k_effb2_metadata/checkpoints.py

@@ -9,8 +9,8 @@ from typing import Any
 import torch
 from torch import nn
 
-CHECKPOINT_STATE_KEYS = ("model_state", "model_state_dict", "state_dict")
-PREFIXES_TO_STRIP = ("module.", "model.", "_orig_mod.")
+CHECKPOINT_STATE_KEYS = ("encoder_state_dict", "model_state", "model_state_dict", "state_dict")
+PREFIXES_TO_STRIP = ("module.", "model.", "encoder.", "backbone.", "_orig_mod.")
 
 
 def extract_state_dict(checkpoint: Any) -> dict[str, torch.Tensor]:
@@ -91,4 +91,3 @@ def load_encoder_checkpoint(path: Path, encoder: nn.Module, branch_name: str, de
     target_state.update(matched)
     encoder.load_state_dict(target_state)
     print(f"{branch_name}: loaded {len(matched)} keys from {path}; skipped {skipped} keys")
-

milk10k_effb2_metadata/cli.py

@@ -9,6 +9,18 @@ from pathlib import Path
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description="Train MILK10k dual-image backbones with metadata fusion.")
     parser.add_argument("--data-dir", type=Path, default=None)
+    parser.add_argument(
+        "--dermoscopic-mask-dir",
+        type=Path,
+        default=None,
+        help="Optional directory containing <lesion_id>_dermoscopic_mask.png files.",
+    )
+    parser.add_argument(
+        "--min-dermoscopic-mask-ratio",
+        type=float,
+        default=0.01,
+        help="Fallback to the original dermoscopic image when mask foreground ratio is below this value.",
+    )
     parser.add_argument(
         "--clinical-checkpoint",
         type=Path,
@@ -35,7 +47,10 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument(
         "--backbone",
         default="efficientnet_b2",
-        help="Backbone model architecture (efficientnet_b2, efficientnet_b1, resnet50, convnext_base).",
+        help=(
+            "Backbone model architecture (efficientnet_b2, tf_efficientnetv2_b2, "
+            "efficientnet_b1, resnet50, convnext_base)."
+        ),
     )
     parser.add_argument(
         "--num-workers",
@@ -122,6 +137,15 @@ def parse_args() -> argparse.Namespace:
     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(
+        "--classifier-style",
+        choices=["legacy", "simple"],
+        default="legacy",
+        help=(
+            "Final fused classifier architecture. legacy keeps the existing LayerNorm/GELU head; "
+            "simple uses Linear-ReLU-Dropout-Linear."
+        ),
+    )
     parser.add_argument("--dropout", type=float, default=0.3)
     parser.add_argument(
         "--logit-fusion-mode",
@@ -135,6 +159,30 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--class-weight", action="store_true")
     parser.add_argument("--weighted-sampler", action="store_true")
     parser.add_argument("--sampler-power", type=float, default=1.0)
+    parser.add_argument(
+        "--balance-mode",
+        choices=["none", "hybrid"],
+        default="none",
+        help="Train-only epoch balancing. hybrid caps the largest class and mildly oversamples eligible tail classes.",
+    )
+    parser.add_argument(
+        "--balance-head-ratio",
+        type=float,
+        default=2.0,
+        help="In hybrid mode, cap the largest class at this multiple of the second-largest class.",
+    )
+    parser.add_argument(
+        "--balance-tail-floor",
+        type=int,
+        default=100,
+        help="In hybrid mode, oversample eligible classes below this count up to this many rows per epoch.",
+    )
+    parser.add_argument(
+        "--balance-min-source-count",
+        type=int,
+        default=20,
+        help="Do not oversample a class with fewer real train rows than this value.",
+    )
     parser.add_argument("--loss", choices=["ce", "focal", "ldam", "ce_dice", "ce_f1"], default="ce")
     parser.add_argument("--focal-gamma", type=float, default=2.0)
     parser.add_argument("--dice-weight", type=float, default=0.3)
@@ -195,4 +243,13 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--calibration-step", type=float, default=0.25)
     parser.add_argument("--calibration-passes", type=int, default=3)
     parser.add_argument("--patience", type=int, default=6)
+    parser.add_argument("--tau", type=float, default=0.0, help="Generalized Balanced Softmax strength in [0, 0.5].")
+    parser.add_argument("--lws-epochs", type=int, default=0, help="Number of LWS post-training epochs; 0 disables LWS.")
+    parser.add_argument("--lws-lr", type=float, default=1e-2)
+    parser.add_argument("--lws-sampler-power", type=float, default=0.5)
+    parser.add_argument("--lws-min-scale", type=float, default=0.75)
+    parser.add_argument("--lws-max-scale", type=float, default=1.5)
+    parser.add_argument("--ema", action="store_true", help="Enable Exponential Moving Average (EMA) for model weights")
+    parser.add_argument("--ema-decay", type=float, default=0.999, help="Decay rate for EMA")
+    parser.add_argument("--fit-temperature", action="store_true", help="Fit one positive validation temperature per checkpoint variant.")
     return parser.parse_args()

milk10k_effb2_metadata/data.py

@@ -11,7 +11,7 @@ import pandas as pd
 import torch
 from PIL import Image, ImageFile
 from sklearn.model_selection import StratifiedKFold, train_test_split
-from torch.utils.data import DataLoader, Dataset, WeightedRandomSampler
+from torch.utils.data import DataLoader, Dataset, Sampler, WeightedRandomSampler
 from torchvision import transforms
 
 from datasets import LABEL_COLUMNS, normalize_image_type
@@ -19,6 +19,110 @@ from datasets import LABEL_COLUMNS, normalize_image_type
 ImageFile.LOAD_TRUNCATED_IMAGES = True
 
 METADATA_COLUMNS = ("age_approx", "sex", "skin_tone_class", "site")
+DERMOSCOPIC_MASK_PATH_COLUMN = "dermoscopic_mask_path"
+DERMOSCOPIC_MASK_RATIO_COLUMN = "dermoscopic_mask_ratio"
+DERMOSCOPIC_MASK_STATUS_COLUMN = "dermoscopic_mask_status"
+
+
+def apply_dermoscopic_mask(image: Image.Image, mask_path: str | Path | None) -> Image.Image:
+    """Return an RGB image with non-mask pixels black, or the original RGB image on read failure."""
+    image = image.convert("RGB")
+    if not isinstance(mask_path, (str, Path)) or not str(mask_path):
+        return image
+    try:
+        with Image.open(mask_path) as mask_image:
+            mask = mask_image.convert("L")
+            if mask.size != image.size:
+                return image
+            binary_mask = mask.point(lambda value: 255 if value else 0)
+            return Image.composite(image, Image.new("RGB", image.size), binary_mask)
+    except (OSError, ValueError):
+        return image
+
+
+def audit_dermoscopic_masks(
+    df: pd.DataFrame,
+    mask_dir: Path,
+    min_foreground_ratio: float = 0.01,
+    mask_id_column: str = "lesion_id",
+    mask_suffix: str = "_dermoscopic_mask.png",
+) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """Attach valid mask paths and return one audit row per paired dermoscopic image."""
+    if not 0.0 <= min_foreground_ratio <= 1.0:
+        raise ValueError("--min-dermoscopic-mask-ratio must be between 0 and 1.")
+    mask_dir = mask_dir.expanduser().resolve()
+    if not mask_dir.is_dir():
+        raise FileNotFoundError(f"Dermoscopic mask directory does not exist: {mask_dir}")
+    if mask_id_column not in df.columns:
+        raise ValueError(f"Mask ID column is missing from dataframe: {mask_id_column}")
+
+    audited_df = df.copy()
+    mask_paths: list[str | None] = []
+    ratios: list[float | None] = []
+    statuses: list[str] = []
+    audit_rows: list[dict[str, Any]] = []
+
+    for _, row in audited_df.iterrows():
+        lesion_id = str(row["lesion_id"])
+        mask_id = str(row[mask_id_column])
+        image_path = Path(row["dermoscopic_path"])
+        mask_path = mask_dir / f"{mask_id}{mask_suffix}"
+        ratio: float | None = None
+        status = "valid"
+        image_size: tuple[int, int] | None = None
+        mask_size: tuple[int, int] | None = None
+
+        if not mask_path.is_file():
+            status = "missing"
+        else:
+            try:
+                with Image.open(image_path) as image:
+                    image_size = image.size
+                with Image.open(mask_path) as mask_image:
+                    mask = mask_image.convert("L")
+                    mask.load()
+                    mask_size = mask.size
+                    histogram = mask.histogram()
+                    total_pixels = mask.width * mask.height
+                    ratio = (total_pixels - histogram[0]) / total_pixels if total_pixels else 0.0
+                if mask_size != image_size:
+                    status = "size_mismatch"
+                elif ratio < min_foreground_ratio:
+                    status = "too_small"
+            except (OSError, ValueError):
+                status = "unreadable"
+
+        valid_path = str(mask_path) if status == "valid" else None
+        mask_paths.append(valid_path)
+        ratios.append(ratio)
+        statuses.append(status)
+        audit_rows.append(
+            {
+                "lesion_id": lesion_id,
+                "mask_id": mask_id,
+                "dermoscopic_path": str(image_path),
+                "mask_path": str(mask_path),
+                "foreground_ratio": ratio,
+                "status": status,
+                "image_size": None if image_size is None else f"{image_size[0]}x{image_size[1]}",
+                "mask_size": None if mask_size is None else f"{mask_size[0]}x{mask_size[1]}",
+            }
+        )
+
+    audited_df[DERMOSCOPIC_MASK_PATH_COLUMN] = mask_paths
+    audited_df[DERMOSCOPIC_MASK_RATIO_COLUMN] = ratios
+    audited_df[DERMOSCOPIC_MASK_STATUS_COLUMN] = statuses
+    return audited_df, pd.DataFrame(audit_rows)
+
+
+def print_mask_audit_summary(audit_df: pd.DataFrame, min_foreground_ratio: float) -> None:
+    counts = audit_df["status"].value_counts().sort_index().to_dict()
+    valid = int(counts.get("valid", 0))
+    print(
+        "Dermoscopic masks: "
+        f"total={len(audit_df)}, valid={valid}, fallback={len(audit_df) - valid}, "
+        f"min_foreground_ratio={min_foreground_ratio:.6f}, status_counts={counts}"
+    )
 
 
 class PairedMilk10kMetadataDataset(Dataset):
@@ -28,6 +132,8 @@ class PairedMilk10kMetadataDataset(Dataset):
         label_to_idx: dict[str, int],
         metadata_spec: dict[str, Any],
         transform=None,
+        strong_transform=None,
+        strong_augment_labels: set[int] | None = None,
     ) -> None:
         self.df = df.reset_index(drop=True)
         self.labels = [label_to_idx[label] for label in self.df["label"].tolist()]
@@ -36,24 +142,87 @@ class PairedMilk10kMetadataDataset(Dataset):
             ignore_mask = self.df["ignore_metadata"].fillna(False).astype(bool).to_numpy()
             self.metadata[ignore_mask] = 0.0
         self.transform = transform
+        self.strong_transform = strong_transform
+        self.strong_augment_labels = strong_augment_labels or set()
 
     def __len__(self) -> int:
         return len(self.df)
 
-    def _load_image(self, path: str) -> torch.Tensor:
+    def _load_image(
+        self,
+        path: str,
+        mask_path: str | Path | None = None,
+        transform=None,
+    ) -> torch.Tensor:
         with Image.open(path) as img:
-            image = img.convert("RGB")
-        if self.transform is not None:
-            image = self.transform(image)
+            image = apply_dermoscopic_mask(img, mask_path)
+        transform = self.transform if transform is None else transform
+        if transform is not None:
+            image = transform(image)
         return image
 
     def __getitem__(self, idx: int) -> dict[str, torch.Tensor]:
         row = self.df.iloc[idx]
+        label = self.labels[idx]
+        transform = self.strong_transform if label in self.strong_augment_labels else self.transform
         return {
-            "clinical": self._load_image(row["clinical_path"]),
-            "dermoscopic": self._load_image(row["dermoscopic_path"]),
+            "clinical": self._load_image(row["clinical_path"], transform=transform),
+            "dermoscopic": self._load_image(
+                row["dermoscopic_path"],
+                row.get(DERMOSCOPIC_MASK_PATH_COLUMN),
+                transform,
+            ),
             "metadata": torch.from_numpy(self.metadata[idx]),
-            "label": torch.tensor(self.labels[idx], dtype=torch.long),
+            "label": torch.tensor(label, dtype=torch.long),
+        }
+
+
+class HybridEpochSampler(Sampler[int]):
+    """Cap the largest class and oversample eligible tail classes per epoch."""
+
+    def __init__(
+        self,
+        labels: list[int],
+        target_counts: np.ndarray,
+        seed: int,
+        label_names: dict[int, str] | None = None,
+    ) -> None:
+        self.labels = np.asarray(labels, dtype=np.int64)
+        self.target_counts = np.asarray(target_counts, dtype=np.int64)
+        self.seed = int(seed)
+        self.epoch = 0
+        self.label_names = label_names or {}
+        self.class_indices = [np.flatnonzero(self.labels == idx) for idx in range(len(self.target_counts))]
+        self.original_counts = np.asarray([len(indices) for indices in self.class_indices], dtype=np.int64)
+
+    def __len__(self) -> int:
+        return int(self.target_counts.sum())
+
+    def set_epoch(self, epoch: int) -> None:
+        self.epoch = int(epoch)
+
+    def __iter__(self):
+        generator = torch.Generator().manual_seed(self.seed + self.epoch)
+        selected: list[torch.Tensor] = []
+        for indices, target in zip(self.class_indices, self.target_counts):
+            source = torch.as_tensor(indices, dtype=torch.long)
+            target = int(target)
+            if target <= len(source):
+                selected.append(source[torch.randperm(len(source), generator=generator)[:target]])
+                continue
+            full_repeats, remainder = divmod(target, len(source))
+            chunks = [source[torch.randperm(len(source), generator=generator)] for _ in range(full_repeats)]
+            if remainder:
+                chunks.append(source[torch.randperm(len(source), generator=generator)[:remainder]])
+            selected.append(torch.cat(chunks))
+        epoch_indices = torch.cat(selected)
+        order = torch.randperm(len(epoch_indices), generator=generator)
+        return iter(epoch_indices[order].tolist())
+
+    def exposure_summary(self) -> dict[str, int]:
+        return {
+            self.label_names.get(idx, str(idx)): int(count)
+            for idx, count in enumerate(self.target_counts)
         }
 
 
@@ -229,6 +398,62 @@ def make_transforms(image_size: int):
     return train_transform, eval_transform
 
 
+def make_strong_train_transform(image_size: int):
+    """A conservative stronger variant used only for oversampled tail classes."""
+    normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+    return transforms.Compose(
+        [
+            transforms.RandomResizedCrop(image_size, scale=(0.65, 1.0), ratio=(1.15, 1.5)),
+            transforms.RandomHorizontalFlip(),
+            transforms.RandomVerticalFlip(),
+            transforms.RandomRotation(30),
+            transforms.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.25),
+            transforms.RandomAffine(degrees=0, translate=(0.05, 0.05), scale=(0.95, 1.05)),
+            transforms.ToTensor(),
+            normalize,
+        ]
+    )
+
+
+def hybrid_target_counts(labels: list[int], args: argparse.Namespace) -> tuple[np.ndarray, set[int]]:
+    """Return per-class epoch targets and classes eligible for strong augmentation."""
+    counts = np.bincount(np.asarray(labels, dtype=np.int64))
+    if np.any(counts == 0):
+        raise ValueError("Cannot build hybrid sampler because at least one class has zero training samples.")
+    targets = counts.copy()
+
+    if len(counts) >= 2:
+        descending = np.argsort(-counts, kind="stable")
+        head_idx, second_idx = int(descending[0]), int(descending[1])
+        head_cap = max(1, int(np.floor(counts[second_idx] * args.balance_head_ratio)))
+        targets[head_idx] = min(int(counts[head_idx]), head_cap)
+
+    strong_labels: set[int] = set()
+    for idx, count in enumerate(counts):
+        if args.balance_min_source_count <= count < args.balance_tail_floor:
+            targets[idx] = args.balance_tail_floor
+            strong_labels.add(idx)
+    return targets, strong_labels
+
+
+def hybrid_balance_summary(
+    labels: list[int],
+    label_names: dict[int, str],
+    args: argparse.Namespace,
+) -> dict[str, Any]:
+    counts = np.bincount(np.asarray(labels, dtype=np.int64))
+    targets, strong_labels = hybrid_target_counts(labels, args)
+    return {
+        "mode": "hybrid",
+        "original_class_counts": {label_names[idx]: int(count) for idx, count in enumerate(counts)},
+        "effective_class_counts_per_epoch": {
+            label_names[idx]: int(count) for idx, count in enumerate(targets)
+        },
+        "strong_augmentation_classes": [label_names[idx] for idx in sorted(strong_labels)],
+        "effective_rows_per_epoch": int(targets.sum()),
+    }
+
+
 def make_loaders(
     train_df: pd.DataFrame,
     val_df: pd.DataFrame,
@@ -237,7 +462,24 @@ def make_loaders(
     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)
+    label_names = {idx: label for label, idx in label_to_idx.items()}
+    train_labels = [label_to_idx[label] for label in train_df["label"].tolist()]
+    sampler = None
+    strong_transform = None
+    strong_labels: set[int] = set()
+    if args.balance_mode == "hybrid":
+        targets, strong_labels = hybrid_target_counts(train_labels, args)
+        sampler = HybridEpochSampler(train_labels, targets, args.seed, label_names)
+        strong_transform = make_strong_train_transform(args.image_size)
+
+    train_ds = PairedMilk10kMetadataDataset(
+        train_df,
+        label_to_idx,
+        metadata_spec,
+        train_transform,
+        strong_transform=strong_transform,
+        strong_augment_labels=strong_labels,
+    )
     val_ds = PairedMilk10kMetadataDataset(val_df, label_to_idx, metadata_spec, eval_transform)
     common = dict(
         batch_size=args.batch_size,
@@ -245,7 +487,8 @@ def make_loaders(
         pin_memory=torch.cuda.is_available(),
         drop_last=False,
     )
-    sampler = build_weighted_sampler(train_ds, args) if args.weighted_sampler else None
+    if args.weighted_sampler:
+        sampler = build_weighted_sampler(train_ds, args)
     train_loader = DataLoader(train_ds, shuffle=sampler is None, sampler=sampler, **common)
     val_loader = DataLoader(val_ds, shuffle=False, **common)
     return train_loader, val_loader

milk10k_effb2_metadata/engine.py

@@ -35,9 +35,11 @@ def run_epoch(
     use_amp: bool = False,
     tail_class_indices: list[int] | None = None,
     class_names: list[str] | None = None,
+    ema_model: nn.Module | None = None,
 ) -> dict[str, float]:
     training = optimizer is not None
     model.train(training)
+    criterion.train(training)
     total_loss = 0.0
     correct = 0
     top3_correct = 0
@@ -65,6 +67,8 @@ def run_epoch(
                     loss.backward()
                     torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
                     optimizer.step()
+                if ema_model is not None:
+                    ema_model.update_parameters(model)
 
         batch_size = labels.size(0)
         total_loss += float(loss.detach().item()) * batch_size
@@ -161,6 +165,7 @@ def save_checkpoint(
     metadata_spec: dict[str, Any],
     args: argparse.Namespace,
     extra: dict[str, Any] | None = None,
+    ema_model: nn.Module | None = None,
 ) -> None:
     payload = {
         "epoch": epoch,
@@ -176,6 +181,8 @@ def save_checkpoint(
         "metadata_spec": metadata_spec,
         "args": json_safe(vars(args)),
     }
+    if ema_model is not None:
+        payload["ema_model_state"] = ema_model.state_dict()
     if extra:
         payload.update(json_safe(extra))
     torch.save(payload, path)
@@ -202,9 +209,12 @@ def train_phase(
     tail_class_names: list[str] | None = None,
     train_class_counts: dict[str, int] | None = None,
     best_val_tail_recall: float = float("-inf"),
-) -> tuple[int, float, float]:
+    ema_model: nn.Module | None = None,
+    variant_best: dict[str, float] | None = None,
+) -> tuple[int, float, float, dict[str, float]]:
+    variant_best = variant_best if variant_best is not None else {"raw": float("-inf"), "ema": float("-inf")}
     if num_epochs <= 0:
-        return start_epoch, best_val_f1, best_val_tail_recall
+        return start_epoch, best_val_f1, best_val_tail_recall, variant_best
 
     encoders_trainable = phase == "finetune"
     set_encoder_trainable(model, encoders_trainable)
@@ -222,6 +232,11 @@ def train_phase(
             continue
         if hasattr(criterion, "set_epoch"):
             criterion.set_epoch(epoch)
+        sampler = getattr(train_loader, "sampler", None)
+        if hasattr(sampler, "set_epoch"):
+            sampler.set_epoch(epoch)
+        if hasattr(sampler, "exposure_summary"):
+            print(f"Hybrid balance epoch {epoch:03d}: effective_class_counts={sampler.exposure_summary()}")
         train_stats = run_epoch(
             model,
             train_loader,
@@ -232,8 +247,9 @@ def train_phase(
             use_amp,
             tail_class_indices,
             class_names,
+            ema_model=ema_model,
         )
-        val_stats = run_epoch(
+        raw_val_stats = run_epoch(
             model,
             val_loader,
             criterion,
@@ -241,14 +257,32 @@ def train_phase(
             tail_class_indices=tail_class_indices,
             class_names=class_names,
         )
+        ema_val_stats = None
+        if ema_model is not None:
+            ema_val_stats = run_epoch(
+                ema_model,
+                val_loader,
+                criterion,
+                device,
+                tail_class_indices=tail_class_indices,
+                class_names=class_names,
+            )
         selection_metric = args.selection_metric
+        candidates = [("raw", raw_val_stats, model)]
+        if ema_val_stats is not None:
+            candidates.append(("ema", ema_val_stats, ema_model.module))
+        epoch_variant, val_stats, epoch_model = max(candidates, key=lambda item: item[1][selection_metric])
         scheduler.step(val_stats[selection_metric])
         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()},
+            **{f"val_raw_{key}": value for key, value in raw_val_stats.items()},
         }
+        if ema_val_stats is not None:
+            row.update({f"val_ema_{key}": value for key, value in ema_val_stats.items()})
+        row["selected_variant"] = epoch_variant
         history.append(row)
         pd.DataFrame(history).to_csv(output_dir / "history.csv", index=False)
         print(
@@ -257,8 +291,26 @@ def train_phase(
             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_dice={val_stats.get('dice_macro', 0.0):.4f} "
-            f"val_top3={val_stats['top3_accuracy']:.4f}"
+            f"val_top3={val_stats['top3_accuracy']:.4f} selected={epoch_variant}"
         )
+        for variant, stats, variant_model in candidates:
+            if stats[selection_metric] <= variant_best.get(variant, float("-inf")):
+                continue
+            variant_best[variant] = float(stats[selection_metric])
+            save_checkpoint(
+                output_dir / f"best_{variant}.pt",
+                variant_model,
+                optimizer,
+                epoch,
+                phase,
+                variant_best[variant],
+                class_names,
+                label_to_idx,
+                metadata_spec,
+                args,
+                {"checkpoint_variant": variant, "variant_val_stats": stats},
+            )
+            print(f"Saved best {variant}: {selection_metric}={variant_best[variant]:.4f}")
         if tail_class_indices:
             print(
                 f"LDAM tail: classes={tail_class_names} "
@@ -274,7 +326,7 @@ def train_phase(
             patience_count = 0
             save_checkpoint(
                 output_dir / "best.pt",
-                model,
+                epoch_model,
                 optimizer,
                 epoch,
                 phase,
@@ -283,6 +335,7 @@ def train_phase(
                 label_to_idx,
                 metadata_spec,
                 args,
+                extra={"checkpoint_variant": epoch_variant, "variant_val_stats": val_stats},
             )
             print(
                 f"Saved best checkpoint: phase={phase} epoch={epoch:03d} "
@@ -311,14 +364,37 @@ def train_phase(
                     "train_class_counts": train_class_counts or {},
                     "selection_metric": "val_tail_recall_macro",
                 },
+                ema_model=ema_model,
             )
             print(
                 f"Saved tail checkpoint: phase={phase} epoch={epoch:03d} "
                 f"best_val_tail_recall_macro={best_val_tail_recall:.4f} path={output_dir / 'tail_best.pt'}"
             )
 
+        save_checkpoint(
+            output_dir / "last.pt",
+            model,
+            optimizer,
+            epoch,
+            phase,
+            best_val_f1,
+            class_names,
+            label_to_idx,
+            metadata_spec,
+            args,
+            {
+                "last_selection_metric": float(val_stats[selection_metric]),
+                "last_val_stats": val_stats,
+            },
+            ema_model=ema_model,
+        )
+        print(
+            f"Saved last checkpoint: phase={phase} epoch={epoch:03d} "
+            f"{selection_metric}={val_stats[selection_metric]:.4f} path={output_dir / 'last.pt'}"
+        )
+
         if patience_count >= args.patience:
             print(f"Early stopping {phase} at epoch {epoch}")
             break
 
-    return epoch + 1, best_val_f1, best_val_tail_recall
+    return epoch + 1, best_val_f1, best_val_tail_recall, variant_best

milk10k_effb2_metadata/inference.py

@@ -15,8 +15,18 @@ from torch.utils.data import DataLoader, Dataset
 from tqdm.auto import tqdm
 
 from datasets import LABEL_COLUMNS, normalize_image_type
-from milk10k_effb2_metadata.data import METADATA_COLUMNS, make_transforms, metadata_vector, resolve_monet_columns
+from milk10k_effb2_metadata.data import (
+    DERMOSCOPIC_MASK_PATH_COLUMN,
+    METADATA_COLUMNS,
+    apply_dermoscopic_mask,
+    audit_dermoscopic_masks,
+    make_transforms,
+    metadata_vector,
+    print_mask_audit_summary,
+    resolve_monet_columns,
+)
 from milk10k_effb2_metadata.metrics import apply_class_bias, compute_metrics
+from milk10k_effb2_metadata.model_setup import load_model_state_compat
 from milk10k_effb2_metadata.models import (
     DualEffB2MetadataClassifier,
     model_class_for_backbone,
@@ -35,9 +45,9 @@ class InferencePairedDataset(Dataset):
     def __len__(self) -> int:
         return len(self.df)
 
-    def _load_image(self, path: str) -> torch.Tensor:
+    def _load_image(self, path: str, mask_path: str | Path | None = None) -> torch.Tensor:
         with Image.open(path) as img:
-            image = img.convert("RGB")
+            image = apply_dermoscopic_mask(img, mask_path)
         if self.transform is not None:
             image = self.transform(image)
         return image
@@ -46,7 +56,10 @@ class InferencePairedDataset(Dataset):
         row = self.df.iloc[idx]
         return {
             "clinical": self._load_image(row["clinical_path"]),
-            "dermoscopic": self._load_image(row["dermoscopic_path"]),
+            "dermoscopic": self._load_image(
+                row["dermoscopic_path"],
+                row.get(DERMOSCOPIC_MASK_PATH_COLUMN),
+            ),
             "metadata": torch.from_numpy(self.metadata[idx]),
         }
 
@@ -63,6 +76,18 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--data-dir", type=Path, default=None, help="Directory containing MILK10k input/metadata files.")
     parser.add_argument("--input-dir", type=Path, default=None, help="Image root. Overrides --data-dir/MILK10k_Training_Input.")
     parser.add_argument("--metadata-csv", type=Path, default=None, help="Metadata CSV. Overrides --data-dir/MILK10k_Training_Metadata.csv.")
+    parser.add_argument(
+        "--dermoscopic-mask-dir",
+        type=Path,
+        default=None,
+        help="Optional directory containing <lesion_id>_dermoscopic_mask.png files.",
+    )
+    parser.add_argument(
+        "--min-dermoscopic-mask-ratio",
+        type=float,
+        default=0.01,
+        help="Fallback to the original dermoscopic image when mask foreground ratio is below this value.",
+    )
     parser.add_argument("--groundtruth-csv", type=Path, default=None, help="Optional ground-truth CSV for metrics.")
     parser.add_argument("--output", type=Path, default=Path("test_predictions.csv"))
     parser.add_argument("--batch-size", type=int, default=16)
@@ -198,18 +223,27 @@ def build_model_from_checkpoint(checkpoint: dict[str, Any], metadata_dim: int, d
         metadata_fusion=checkpoint_arg(checkpoint_args, "metadata_fusion", "concat"),
         image_fusion=checkpoint_arg(checkpoint_args, "image_fusion", "concat"),
         metadata_gate_hidden_dim=checkpoint_args.get("metadata_gate_hidden_dim"),
+        classifier_style=checkpoint_arg(checkpoint_args, "classifier_style", "legacy"),
         logit_fusion_mode=checkpoint_arg(checkpoint_args, "logit_fusion_mode", "single"),
         fusion_logit_weight=checkpoint_arg(checkpoint_args, "fusion_logit_weight", 0.6),
         clinical_logit_weight=checkpoint_arg(checkpoint_args, "clinical_logit_weight", 0.2),
         dermoscopic_logit_weight=checkpoint_arg(checkpoint_args, "dermoscopic_logit_weight", 0.2),
     ).to(device)
-    model.load_state_dict(state)
+    load_model_state_compat(model, state)
     model.eval()
     return model
 
 
 @torch.no_grad()
-def predict_dataframe(model: DualEffB2MetadataClassifier, loader: DataLoader, device: torch.device, tta_flips: bool = False) -> np.ndarray:
+def predict_dataframe(
+    model: DualEffB2MetadataClassifier,
+    loader: DataLoader,
+    device: torch.device,
+    tta_flips: bool = False,
+    temperature: float = 1.0,
+) -> np.ndarray:
+    if temperature <= 0.0:
+        raise ValueError(f"Checkpoint temperature must be positive, got {temperature}.")
     probs_all = []
     for batch in tqdm(loader, leave=False):
         clinical = batch["clinical"].to(device, non_blocking=True)
@@ -227,7 +261,7 @@ def predict_dataframe(model: DualEffB2MetadataClassifier, loader: DataLoader, de
         probs = None
         for clinical_view, dermoscopic_view in views:
             logits = model(clinical_view, dermoscopic_view, metadata)
-            view_prob = torch.softmax(logits, dim=1)
+            view_prob = torch.softmax(logits / temperature, dim=1)
             probs = view_prob if probs is None else probs + view_prob
         probs_all.append((probs / len(views)).cpu().numpy())
     return np.concatenate(probs_all)
@@ -294,6 +328,21 @@ def main() -> None:
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     input_dir, metadata_csv, groundtruth_csv = resolve_input_paths(args)
     df = load_inference_dataframe(input_dir, metadata_csv, groundtruth_csv)
+    if not 0.0 <= args.min_dermoscopic_mask_ratio <= 1.0:
+        raise ValueError("--min-dermoscopic-mask-ratio must be between 0 and 1.")
+    if args.dermoscopic_mask_dir is not None:
+        args.dermoscopic_mask_dir = args.dermoscopic_mask_dir.expanduser().resolve()
+        df, mask_audit = audit_dermoscopic_masks(
+            df,
+            args.dermoscopic_mask_dir,
+            args.min_dermoscopic_mask_ratio,
+            mask_id_column="dermoscopic_isic_id",
+            mask_suffix="_mask.png",
+        )
+        audit_output = args.output.with_name(f"{args.output.stem}.mask_audit.csv")
+        audit_output.parent.mkdir(parents=True, exist_ok=True)
+        mask_audit.to_csv(audit_output, index=False)
+        print_mask_audit_summary(mask_audit, args.min_dermoscopic_mask_ratio)
     checkpoint_paths = resolve_checkpoint_paths(args)
     ensemble_probs = []
     class_names: list[str] | None = None
@@ -324,7 +373,18 @@ def main() -> None:
             shuffle=False,
         )
         model = build_model_from_checkpoint(checkpoint, dataset.metadata.shape[1], device)
-        y_prob = predict_dataframe(model, loader, device, tta_flips=args.tta_flips)
+        temperature = float(checkpoint.get("temperature", 1.0))
+        y_prob = predict_dataframe(
+            model,
+            loader,
+            device,
+            tta_flips=args.tta_flips,
+            temperature=temperature,
+        )
+        print(
+            f"Checkpoint {checkpoint_path.name}: variant={checkpoint.get('checkpoint_variant', 'legacy')}, "
+            f"temperature={temperature:.4f}"
+        )
         class_bias = load_calibration_bias(checkpoint_path, args, checkpoint_class_names)
         if class_bias is not None:
             y_prob = apply_class_bias(y_prob, class_bias)
@@ -334,6 +394,23 @@ def main() -> None:
     y_prob = np.mean(ensemble_probs, axis=0)
     save_inference_outputs(df, y_prob, class_names, args.output, args.include_debug_columns)
 
+    y_pred = y_prob.argmax(axis=1)
+    for tail_name in ("DF", "INF"):
+        if tail_name not in class_names:
+            continue
+        idx = class_names.index(tail_name)
+        predicted_count = int((y_pred == idx).sum())
+        max_probability = float(y_prob[:, idx].max())
+        mean_probability = float(y_prob[:, idx].mean())
+        print(
+            f"Tail audit {tail_name}: predicted_count={predicted_count}, "
+            f"mean_probability={mean_probability:.6f}, max_probability={max_probability:.6f}"
+        )
+        if predicted_count == 0:
+            print(f"WARNING: no sample is predicted as {tail_name}.")
+        if max_probability < 0.01:
+            print(f"WARNING: {tail_name} maximum probability is below 0.01.")
+
     print(f"Saved predictions: {args.output}")
     if "label" in df.columns and df["label"].notna().all():
         label_to_idx = {label: idx for idx, label in enumerate(class_names)}

milk10k_effb2_metadata/losses.py

@@ -27,6 +27,31 @@ class FocalLoss(nn.Module):
         return loss.mean()
 
 
+class GeneralizedBalancedSoftmaxLoss(nn.Module):
+    def __init__(
+        self,
+        class_counts: torch.Tensor,
+        tau: float = 1.0,
+        weight: torch.Tensor | None = None,
+    ) -> None:
+        super().__init__()
+        if not 0.0 <= tau <= 0.5:
+            raise ValueError("--tau must be between 0.0 and 0.5.")
+        if weight is not None:
+            raise ValueError("Generalized Balanced Softmax cannot be combined with class weights.")
+        self.tau = tau
+        counts = class_counts.float().clamp_min(1.0)
+        self.register_buffer("log_counts", torch.log(counts))
+
+    def forward(self, logits: torch.Tensor, labels: torch.Tensor) -> torch.Tensor:
+        if self.training and self.tau > 0.0:
+            log_counts = self.log_counts.to(device=logits.device, dtype=logits.dtype)
+            adjusted_logits = logits + self.tau * log_counts
+        else:
+            adjusted_logits = logits
+        return F.cross_entropy(adjusted_logits, labels)
+
+
 class LDAMLoss(nn.Module):
     """LDAM with deferred effective-number reweighting."""
 
@@ -179,7 +204,14 @@ def build_loss(train_df: pd.DataFrame, label_to_idx: dict[str, int], args: argpa
         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)
-    ce_loss: nn.Module = nn.CrossEntropyLoss(weight=weight)
+        
+    if getattr(args, "tau", 0.0) > 0.0:
+        if args.class_weight:
+            raise ValueError("--tau > 0 cannot be combined with --class-weight.")
+        counts = class_count_tensor(train_df, label_to_idx, device)
+        ce_loss: nn.Module = GeneralizedBalancedSoftmaxLoss(counts, tau=args.tau)
+    else:
+        ce_loss: nn.Module = nn.CrossEntropyLoss(weight=weight)
     if args.loss == "focal":
         return FocalLoss(weight=weight, gamma=args.focal_gamma)
     if args.loss == "ce_dice":

milk10k_effb2_metadata/metrics.py

@@ -13,6 +13,7 @@ from sklearn.metrics import (
     balanced_accuracy_score,
     classification_report,
     confusion_matrix,
+    log_loss,
     precision_recall_fscore_support,
     roc_auc_score,
 )
@@ -56,6 +57,9 @@ def macro_dice_from_confusion_matrix(cm: np.ndarray) -> float:
 
 
 def compute_metrics(y_true: np.ndarray, y_prob: np.ndarray, class_names: list[str]) -> tuple[dict[str, Any], pd.DataFrame, np.ndarray]:
+    y_prob = np.asarray(y_prob, dtype=np.float64)
+    y_prob = np.clip(y_prob, 1e-12, 1.0)
+    y_prob = y_prob / y_prob.sum(axis=1, keepdims=True)
     y_pred = y_prob.argmax(axis=1)
     labels = list(range(len(class_names)))
     y_true_bin = label_binarize(y_true, classes=labels)
@@ -91,11 +95,23 @@ def compute_metrics(y_true: np.ndarray, y_prob: np.ndarray, class_names: list[st
                 "specificity": tn / (tn + fp) if (tn + fp) else 0.0,
                 "f1": float(f1_per_class[idx]),
                 "auc_ovr": auc_ovr,
+                "mean_correct_confidence": (
+                    float(y_prob[(y_true == idx) & (y_pred == idx), idx].mean())
+                    if np.any((y_true == idx) & (y_pred == idx))
+                    else None
+                ),
             }
         )
 
+    correct_mask = y_pred == y_true
+    confidence = y_prob.max(axis=1)
+
     metrics = {
         "accuracy": float(accuracy_score(y_true, y_pred)),
+        "nll": float(log_loss(y_true, y_prob, labels=labels)),
+        "ece": expected_calibration_error(y_true, y_prob),
+        "mean_confidence": float(confidence.mean()),
+        "mean_correct_confidence": float(confidence[correct_mask].mean()) if np.any(correct_mask) else None,
         "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))),
@@ -124,6 +140,23 @@ def compute_metrics(y_true: np.ndarray, y_prob: np.ndarray, class_names: list[st
     return metrics, pd.DataFrame(per_class_rows), cm
 
 
+def expected_calibration_error(y_true: np.ndarray, y_prob: np.ndarray, bins: int = 15) -> float:
+    y_pred = y_prob.argmax(axis=1)
+    confidence = y_prob.max(axis=1)
+    correct = (y_pred == y_true).astype(np.float64)
+    edges = np.linspace(0.0, 1.0, bins + 1)
+    ece = 0.0
+    for idx in range(bins):
+        lower, upper = edges[idx], edges[idx + 1]
+        mask = (confidence > lower) & (confidence <= upper)
+        if idx == 0:
+            mask |= confidence == 0.0
+        if not np.any(mask):
+            continue
+        ece += float(mask.mean()) * abs(float(correct[mask].mean()) - float(confidence[mask].mean()))
+    return float(ece)
+
+
 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"))

milk10k_effb2_metadata/model_setup.py

@@ -15,6 +15,20 @@ from milk10k_effb2_metadata.checkpoints import (
 from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier, model_class_for_backbone
 
 
+def load_model_state_compat(model: DualEffB2MetadataClassifier, state: dict[str, torch.Tensor]) -> None:
+    """Load checkpoints created before LWS added the class_scales parameter."""
+    incompatible = model.load_state_dict(state, strict=False)
+    missing = set(incompatible.missing_keys)
+    unexpected = set(incompatible.unexpected_keys)
+    allowed_missing = {"class_scales"}
+    if missing - allowed_missing or unexpected:
+        raise RuntimeError(
+            f"Checkpoint state mismatch: missing={sorted(missing)}, unexpected={sorted(unexpected)}"
+        )
+    if "class_scales" in missing:
+        model.class_scales.data.fill_(1.0)
+
+
 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.")
@@ -103,6 +117,7 @@ def load_resume_checkpoint(
     checkpoint_path: Path | None,
     model: DualEffB2MetadataClassifier,
     device: torch.device,
+    ema_model: torch.nn.Module | None = None,
 ) -> tuple[int, float, str | None]:
     if checkpoint_path is None:
         return 1, float("-inf"), None
@@ -110,7 +125,9 @@ def load_resume_checkpoint(
     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"])
+    load_model_state_compat(model, checkpoint["model_state"])
+    if ema_model is not None and "ema_model_state" in checkpoint:
+        ema_model.load_state_dict(checkpoint["ema_model_state"])
     next_epoch = int(checkpoint.get("epoch", 0)) + 1
     best_val_f1 = float(
         checkpoint.get(
@@ -152,6 +169,7 @@ def build_model(
         metadata_fusion=args.metadata_fusion,
         image_fusion=getattr(args, "image_fusion", "concat"),
         metadata_gate_hidden_dim=args.metadata_gate_hidden_dim,
+        classifier_style=getattr(args, "classifier_style", "legacy"),
         logit_fusion_mode=args.logit_fusion_mode,
         fusion_logit_weight=args.fusion_logit_weight,
         clinical_logit_weight=args.clinical_logit_weight,

milk10k_effb2_metadata/models.py

@@ -107,6 +107,7 @@ class DualEffB2MetadataClassifier(nn.Module):
         metadata_fusion: str = "concat",
         image_fusion: str = "concat",
         metadata_gate_hidden_dim: int | None = None,
+        classifier_style: str = "legacy",
         logit_fusion_mode: str = "single",
         fusion_logit_weight: float = 0.6,
         clinical_logit_weight: float = 0.2,
@@ -128,6 +129,8 @@ class DualEffB2MetadataClassifier(nn.Module):
             raise ValueError(f"Unsupported image_fusion: {image_fusion}")
         if logit_fusion_mode not in ("single", "fixed"):
             raise ValueError(f"Unsupported logit_fusion_mode: {logit_fusion_mode}")
+        if classifier_style not in ("legacy", "simple"):
+            raise ValueError(f"Unsupported classifier_style: {classifier_style}")
         self.clinical_backbone_backend = clinical_backbone_backend
         self.dermoscopic_backbone_backend = dermoscopic_backbone_backend
         self.backbone = normalize_backbone_name(backbone)
@@ -135,6 +138,7 @@ class DualEffB2MetadataClassifier(nn.Module):
         self.metadata_dim = metadata_dim
         self.metadata_fusion = metadata_fusion
         self.image_fusion = image_fusion
+        self.classifier_style = classifier_style
         self.logit_fusion_mode = logit_fusion_mode
         self.fusion_logit_weight = fusion_logit_weight
         self.clinical_logit_weight = clinical_logit_weight
@@ -212,16 +216,37 @@ class DualEffB2MetadataClassifier(nn.Module):
             if clinical_feature_dim != dermoscopic_feature_dim:
                 raise ValueError("shared_private image fusion requires matching branch feature dimensions.")
             self.shared_head = ProjectionHead(clinical_feature_dim, branch_dim, dropout)
-        self.classifier = None if image_fusion == "moe" else self._classifier(fused_dim, classifier_hidden_dim, num_classes, dropout)
+        self.classifier = (
+            None
+            if image_fusion == "moe"
+            else self._classifier(fused_dim, classifier_hidden_dim, num_classes, dropout, classifier_style)
+        )
         if logit_fusion_mode == "fixed":
             self.clinical_classifier = BranchClassifier(branch_dim, num_classes, dropout)
             self.dermoscopic_classifier = BranchClassifier(branch_dim, num_classes, dropout)
         else:
             self.clinical_classifier = None
             self.dermoscopic_classifier = None
+            
+        # LWS is a post-training stage. Keep scales frozen during normal
+        # representation/classifier training and enable them explicitly later.
+        self.class_scales = nn.Parameter(torch.ones(num_classes), requires_grad=False)
 
     @staticmethod
-    def _classifier(in_dim: int, hidden_dim: int, num_classes: int, dropout: float) -> nn.Sequential:
+    def _classifier(
+        in_dim: int,
+        hidden_dim: int,
+        num_classes: int,
+        dropout: float,
+        classifier_style: str,
+    ) -> nn.Sequential:
+        if classifier_style == "simple":
+            return nn.Sequential(
+                nn.Linear(in_dim, hidden_dim),
+                nn.ReLU(),
+                nn.Dropout(dropout),
+                nn.Linear(hidden_dim, num_classes),
+            )
         return nn.Sequential(
             nn.LayerNorm(in_dim),
             nn.Dropout(dropout),
@@ -287,14 +312,14 @@ class DualEffB2MetadataClassifier(nn.Module):
             fused = self._fused_features(clinical_features, dermoscopic_features, clinical_repr, dermoscopic_repr, metadata_repr)
             fusion_logits = self.classifier(fused)
         if self.logit_fusion_mode != "fixed":
-            return fusion_logits
+            return fusion_logits * self.class_scales
         clinical_logits = self.clinical_classifier(clinical_repr)
         dermoscopic_logits = self.dermoscopic_classifier(dermoscopic_repr)
         return (
             self.fusion_logit_weight * fusion_logits
             + self.clinical_logit_weight * clinical_logits
             + self.dermoscopic_logit_weight * dermoscopic_logits
-        )
+        ) * self.class_scales
 
     def _append_metadata(self, features: torch.Tensor, metadata_repr: torch.Tensor | None) -> torch.Tensor:
         if metadata_repr is None:
@@ -401,6 +426,8 @@ class DualConvNeXtMetadataClassifier(DualEffB2MetadataClassifier):
 
 def normalize_backbone_name(name: str) -> str:
     name = name.lower().replace(" ", "").replace("_", "").replace("-", "")
+    if name in ("tfefficientnetv2b2", "efficientnetv2b2", "effnetv2b2", "effv2b2"):
+        return "tf_efficientnetv2_b2"
     if name in ("efficientnetb2", "effnetb2", "effb2"):
         return "efficientnet_b2"
     if name in ("efficientnetb1", "effnetb1", "effb1"):
@@ -425,6 +452,8 @@ def default_image_size(backbone: str) -> int:
     backbone = normalize_backbone_name(backbone)
     if backbone == "efficientnet_b2":
         return 260
+    if backbone == "tf_efficientnetv2_b2":
+        return 384
     if backbone == "efficientnet_b1":
         return 240
     if backbone == "convnext_base":
@@ -478,6 +507,8 @@ def build_feature_encoder(backbone: str, backbone_backend: str, imagenet_pretrai
         return model, int(model.num_features)
 
     if backbone_backend == "torchvision":
+        if backbone == "tf_efficientnetv2_b2":
+            raise ValueError("tf_efficientnetv2_b2 is only available with --backbone-backend timm.")
         if backbone == "efficientnet_b2":
             from torchvision.models import efficientnet_b2, EfficientNet_B2_Weights
             weights = EfficientNet_B2_Weights.IMAGENET1K_V1 if imagenet_pretrained else None

milk10k_effb2_metadata/reporting.py

@@ -95,6 +95,11 @@ def class_distribution(df: pd.DataFrame, class_names: list[str]) -> dict[str, An
         if len(df)
         else {name: 0 for name in class_names}
     )
+    mask_status_counts = (
+        df["dermoscopic_mask_status"].fillna("not_audited").value_counts().sort_index().astype(int).to_dict()
+        if "dermoscopic_mask_status" in df.columns
+        else {}
+    )
     return {
         "rows": int(len(df)),
         "class_counts": counts,
@@ -102,6 +107,7 @@ def class_distribution(df: pd.DataFrame, class_names: list[str]) -> dict[str, An
         "synthetic_rows": int(is_augmented.sum()),
         "synthetic_class_counts": augmented_counts,
         "ignore_metadata_rows": int(ignore_metadata.sum()),
+        "dermoscopic_mask_status_counts": mask_status_counts,
     }
 
 
@@ -353,6 +359,21 @@ def render_split_summary(data_summary: dict[str, Any]) -> str:
             lines.append(f"| {class_name} | {count} | {summary['synthetic_class_counts'].get(class_name, 0)} |")
         lines.append("")
     lines.append(f"- synthetic_train_only: {data_summary['synthetic_train_only']}")
+    balance = data_summary.get("balance")
+    if balance:
+        lines.extend(
+            [
+                f"- balance_mode: {balance['mode']}",
+                f"- effective_rows_per_epoch: {balance['effective_rows_per_epoch']}",
+                f"- strong_augmentation_classes: {balance['strong_augmentation_classes']}",
+                "",
+                "| class | original train | effective per epoch |",
+                "|---|---:|---:|",
+            ]
+        )
+        for class_name, count in balance["original_class_counts"].items():
+            effective = balance["effective_class_counts_per_epoch"][class_name]
+            lines.append(f"| {class_name} | {count} | {effective} |")
     lines.append("")
     return "\n".join(lines)
 
@@ -380,7 +401,13 @@ def render_run_report(
             f"- loss: {getattr(args, 'loss', None)}",
             f"- class_weight: {getattr(args, 'class_weight', None)}",
             f"- weighted_sampler: {getattr(args, 'weighted_sampler', None)}",
+            f"- balance_mode: {getattr(args, 'balance_mode', None)}",
+            f"- balance_head_ratio: {getattr(args, 'balance_head_ratio', None)}",
+            f"- balance_tail_floor: {getattr(args, 'balance_tail_floor', None)}",
+            f"- balance_min_source_count: {getattr(args, 'balance_min_source_count', None)}",
             f"- augmented_data_dir: {getattr(args, 'augmented_data_dir', None)}",
+            f"- dermoscopic_mask_dir: {getattr(args, 'dermoscopic_mask_dir', None)}",
+            f"- min_dermoscopic_mask_ratio: {getattr(args, 'min_dermoscopic_mask_ratio', None)}",
             f"- augmented_classes: {getattr(args, 'augmented_classes', None)}",
             f"- augmented_max_per_class: {getattr(args, 'augmented_max_per_class', None)}",
             f"- freeze_metadata_head: {getattr(args, 'freeze_metadata_head', None)}",

milk10k_effb2_metadata/runner.py

@@ -7,11 +7,16 @@ import json
 from pathlib import Path
 from typing import Any
 
+import numpy as np
 import pandas as pd
 import torch
+import torch.nn.functional as F
+from torch import nn
+from torch.utils.data import DataLoader, WeightedRandomSampler
 
 from milk10k_effb2_metadata.data import (
     fit_metadata_spec,
+    hybrid_balance_summary,
     kfold_splits,
     lesion_split,
     load_paired_dataframe,
@@ -21,10 +26,162 @@ from milk10k_effb2_metadata.data import (
 from milk10k_effb2_metadata.engine import train_phase
 from milk10k_effb2_metadata.losses import build_loss
 from milk10k_effb2_metadata.metrics import apply_class_bias, compute_metrics, optimize_class_bias, predict, save_predictions
-from milk10k_effb2_metadata.model_setup import build_model, load_resume_checkpoint
+from milk10k_effb2_metadata.model_setup import build_model, load_model_state_compat, load_resume_checkpoint
+from milk10k_effb2_metadata.models import DualEffB2MetadataClassifier
 from milk10k_effb2_metadata.reporting import build_data_summary, save_data_summary, save_kfold_report, save_run_diagnostics
 from milk10k_effb2_metadata.training_utils import json_safe, save_kfold_summary, save_run_config
 
+def train_lws_post_training(
+    model: DualEffB2MetadataClassifier,
+    train_loader: DataLoader,
+    val_loader: DataLoader,
+    device: torch.device,
+    args: argparse.Namespace,
+    source_checkpoint: dict[str, Any],
+    output_path: Path,
+) -> dict[str, Any] | None:
+    if args.lws_epochs <= 0:
+        return None
+
+    print(f"\nStarting LWS Post-Training for {args.lws_epochs} epochs...")
+    model.requires_grad_(False)
+    model.class_scales.data.fill_(1.0)
+    model.class_scales.requires_grad_(True)
+    optimizer = torch.optim.Adam([model.class_scales], lr=args.lws_lr)
+    criterion = nn.CrossEntropyLoss()
+
+    dataset = train_loader.dataset
+    labels = np.asarray(dataset.labels, dtype=np.int64)
+    counts = np.bincount(labels)
+    class_weights = 1.0 / np.power(counts.astype(np.float64), args.lws_sampler_power)
+    generator = torch.Generator().manual_seed(args.seed)
+    lws_sampler = WeightedRandomSampler(
+        torch.as_tensor(class_weights[labels], dtype=torch.double),
+        num_samples=len(dataset),
+        replacement=True,
+        generator=generator,
+    )
+    lws_loader = DataLoader(
+        dataset,
+        batch_size=args.batch_size,
+        num_workers=args.num_workers,
+        pin_memory=torch.cuda.is_available(),
+        sampler=lws_sampler,
+    )
+
+    # Keep dropout and batch normalization disabled. Gradients still flow to
+    # class_scales while every representation/classifier parameter is frozen.
+    model.eval()
+    from milk10k_effb2_metadata.metrics import move_batch
+    best_score = float("-inf")
+    best_metrics: dict[str, Any] | None = None
+    for epoch in range(1, args.lws_epochs + 1):
+        total_loss = 0.0
+        for batch in lws_loader:
+            clinical, dermoscopic, metadata, labels = move_batch(batch, device)
+            optimizer.zero_grad()
+            logits = model(clinical, dermoscopic, metadata)
+            loss = criterion(logits, labels)
+            loss.backward()
+            optimizer.step()
+
+            model.class_scales.data.clamp_(args.lws_min_scale, args.lws_max_scale)
+            total_loss += loss.item()
+
+        y_true, y_prob = predict(model, val_loader, device)
+        metrics, _, _ = compute_metrics(y_true, y_prob, source_checkpoint["class_names"])
+        scales_str = np.array2string(model.class_scales.detach().cpu().numpy(), precision=3, separator=',')
+        print(
+            f"LWS Epoch {epoch}/{args.lws_epochs} - Loss: {total_loss / max(len(lws_loader), 1):.4f} "
+            f"- F1: {metrics['f1_macro']:.4f} - Scales: {scales_str}"
+        )
+        if metrics[args.selection_metric] > best_score:
+            best_score = float(metrics[args.selection_metric])
+            best_metrics = metrics
+            payload = dict(source_checkpoint)
+            payload["model_state"] = {
+                name: value.detach().cpu().clone() for name, value in model.state_dict().items()
+            }
+            payload["checkpoint_variant"] = "lws"
+            payload["best_selection_metric"] = best_score
+            payload["best_val_f1_macro"] = float(metrics["f1_macro"])
+            payload["lws_epoch"] = epoch
+            payload["lws_scales"] = model.class_scales.detach().cpu().tolist()
+            payload["variant_val_metrics"] = json_safe(metrics)
+            torch.save(payload, output_path)
+    model.class_scales.requires_grad_(False)
+    return best_metrics
+
+def fit_global_temperature(
+    model: nn.Module,
+    val_loader: DataLoader,
+    device: torch.device,
+) -> float:
+    model.eval()
+    all_logits = []
+    all_labels = []
+    from milk10k_effb2_metadata.metrics import move_batch
+    with torch.no_grad():
+        for batch in val_loader:
+            clinical, dermoscopic, metadata, labels = move_batch(batch, device)
+            logits = model(clinical, dermoscopic, metadata)
+            all_logits.append(logits)
+            all_labels.append(labels)
+            
+    all_logits = torch.cat(all_logits)
+    all_labels = torch.cat(all_labels)
+    
+    log_temperature = torch.nn.Parameter(torch.zeros(1, device=device))
+    optimizer = torch.optim.LBFGS([log_temperature], lr=0.05, max_iter=50)
+    
+    def eval_fn():
+        optimizer.zero_grad()
+        temperature = log_temperature.exp().clamp(0.05, 20.0)
+        loss = F.cross_entropy(all_logits / temperature, all_labels)
+        loss.backward()
+        return loss
+        
+    optimizer.step(eval_fn)
+    return float(log_temperature.detach().exp().clamp(0.05, 20.0).item())
+
+
+@torch.no_grad()
+def predict_temperature(
+    model: nn.Module,
+    loader: DataLoader,
+    device: torch.device,
+    temperature: float,
+) -> tuple[np.ndarray, np.ndarray]:
+    from milk10k_effb2_metadata.metrics import move_batch
+
+    model.eval()
+    labels_all: list[np.ndarray] = []
+    probs_all: list[np.ndarray] = []
+    for batch in loader:
+        clinical, dermoscopic, metadata, labels = move_batch(batch, device)
+        logits = model(clinical, dermoscopic, metadata) / temperature
+        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 add_head_confidence_metrics(
+    metrics: dict[str, Any],
+    y_true: np.ndarray,
+    y_prob: np.ndarray,
+    class_names: list[str],
+    train_df: pd.DataFrame,
+    min_support: int = 100,
+) -> None:
+    train_counts = train_df["label"].value_counts()
+    head_indices = [idx for idx, name in enumerate(class_names) if int(train_counts.get(name, 0)) >= min_support]
+    y_pred = y_prob.argmax(axis=1)
+    mask = np.isin(y_true, head_indices) & (y_pred == y_true)
+    metrics["head_class_names"] = [class_names[idx] for idx in head_indices]
+    metrics["mean_correct_confidence_head"] = (
+        float(y_prob[mask, y_true[mask]].mean()) if np.any(mask) else None
+    )
+
 
 def build_tail_tracking_config(
     train_df: pd.DataFrame,
@@ -55,6 +212,11 @@ def resolve_label_name(class_names: list[str], name: str) -> str:
     return normalized[key]
 
 
+def source_lesion_id(value: Any) -> str:
+    """Return the original lesion ID for a generated paired lesion ID."""
+    return str(value).split("__sdpair_", 1)[0]
+
+
 def load_augmented_subset(
     base_df: pd.DataFrame,
     class_names: list[str],
@@ -74,14 +236,6 @@ def load_augmented_subset(
     augmented_max_per_class = getattr(args, "augmented_max_per_class", 0)
     if augmented_max_per_class < 0:
         raise ValueError("--augmented-max-per-class must be >= 0.")
-    if augmented_max_per_class > 0 and not augmented_df.empty:
-        augmented_df = (
-            augmented_df.sample(frac=1.0, random_state=args.seed)
-            .groupby("label", group_keys=False)
-            .head(augmented_max_per_class)
-            .sort_values(["label", "lesion_id"])
-            .reset_index(drop=True)
-        )
     augmented_df["is_augmented"] = True
     augmented_df["ignore_metadata"] = bool(getattr(args, "zero_augmented_metadata", False))
     return augmented_df
@@ -90,6 +244,7 @@ def load_augmented_subset(
 def append_augmented_train_rows(
     base_df: pd.DataFrame,
     train_df: pd.DataFrame,
+    val_df: pd.DataFrame,
     class_names: list[str],
     args: argparse.Namespace,
 ) -> pd.DataFrame:
@@ -98,10 +253,39 @@ def append_augmented_train_rows(
         if getattr(args, "augmented_data_dir", None) is not None:
             print("Augmented data: no extra rows selected.")
         return train_df
+    train_source_ids = set(train_df["lesion_id"].astype(str).map(source_lesion_id))
+    val_source_ids = set(val_df["lesion_id"].astype(str).map(source_lesion_id))
+    augmented_df["source_lesion_id"] = augmented_df["lesion_id"].astype(str).map(source_lesion_id)
+    source_overlap = train_source_ids & val_source_ids
+    if source_overlap:
+        raise RuntimeError(
+            f"Source leakage already exists between train and validation: {len(source_overlap)} lesion IDs."
+        )
+    selected = augmented_df["source_lesion_id"].isin(train_source_ids)
+    excluded_validation = augmented_df["source_lesion_id"].isin(val_source_ids)
+    unknown = ~(selected | excluded_validation)
+    if unknown.any():
+        examples = augmented_df.loc[unknown, "lesion_id"].astype(str).head(5).tolist()
+        raise ValueError(
+            "Augmented lesions cannot be mapped to an original train/validation source. "
+            f"Examples: {examples}"
+        )
+    excluded_count = int(excluded_validation.sum())
+    augmented_df = augmented_df.loc[selected].copy()
+    augmented_max_per_class = getattr(args, "augmented_max_per_class", 0)
+    if augmented_max_per_class > 0 and not augmented_df.empty:
+        augmented_df = (
+            augmented_df.sample(frac=1.0, random_state=args.seed)
+            .groupby("label", group_keys=False)
+            .head(augmented_max_per_class)
+            .sort_values(["label", "lesion_id"])
+            .reset_index(drop=True)
+        )
     counts = augmented_df["label"].value_counts().sort_index().to_dict()
     print(
-        "Augmented train append: "
+        "Source-safe augmented train append: "
         f"rows={len(augmented_df)}, counts={counts}, "
+        f"excluded_validation_sources={excluded_count}, "
         f"zero_metadata={getattr(args, 'zero_augmented_metadata', False)}, "
         f"source={getattr(args, 'augmented_data_dir', None)}"
     )
@@ -127,6 +311,12 @@ def run_training_split(
     train_df.to_csv(split_dir / "train.csv", index=False)
     val_df.to_csv(split_dir / "val.csv", index=False)
     data_summary = build_data_summary(df, train_df, val_df, class_names)
+    if args.balance_mode == "hybrid":
+        data_summary["balance"] = hybrid_balance_summary(
+            [label_to_idx[label] for label in train_df["label"].tolist()],
+            {idx: label for label, idx in label_to_idx.items()},
+            args,
+        )
     save_data_summary(output_dir, data_summary)
 
     metadata_spec = fit_metadata_spec(train_df)
@@ -152,7 +342,13 @@ def run_training_split(
         clinical_backbone_backend,
         dermoscopic_backbone_backend,
     )
-    resume_epoch, resume_best_val_f1, resume_phase = load_resume_checkpoint(args.resume_checkpoint, model, device)
+    
+    ema_model = None
+    if getattr(args, "ema", False):
+        from torch.optim.swa_utils import AveragedModel, get_ema_multi_avg_fn
+        ema_model = AveragedModel(model, multi_avg_fn=get_ema_multi_avg_fn(args.ema_decay))
+        
+    resume_epoch, resume_best_val_f1, resume_phase = load_resume_checkpoint(args.resume_checkpoint, model, device, ema_model=ema_model)
     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)
     tail_config = build_tail_tracking_config(train_df, class_names, label_to_idx, args)
@@ -169,7 +365,12 @@ def run_training_split(
         f"metadata_fusion={args.metadata_fusion}, image_fusion={getattr(args, 'image_fusion', 'concat')}, "
         f"gate_hidden_dim={args.metadata_gate_hidden_dim}"
     )
-    print(f"Loss: {args.loss}, class_weight={args.class_weight}, weighted_sampler={args.weighted_sampler}")
+    print(
+        f"Loss: {args.loss}, class_weight={args.class_weight}, weighted_sampler={args.weighted_sampler}, "
+        f"balance_mode={args.balance_mode}"
+    )
+    if args.balance_mode == "hybrid":
+        print(f"Hybrid balance plan: {data_summary['balance']}")
     if getattr(args, "image_fusion", "concat") == "moe" and args.logit_fusion_mode == "fixed":
         print("Note: --image-fusion moe already mixes expert logits; --logit-fusion-mode fixed adds extra branch logits.")
     if args.loss == "ce_f1":
@@ -194,7 +395,8 @@ def run_training_split(
     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, best_val_tail_recall = train_phase(
+    variant_best = {"raw": float("-inf"), "ema": float("-inf")}
+    epoch, best_val_f1, best_val_tail_recall, variant_best = train_phase(
         "freeze",
         args.freeze_epochs,
         1,
@@ -213,8 +415,10 @@ def run_training_split(
         skip_freeze_until,
         **(tail_config or {}),
         best_val_tail_recall=best_tail_start,
+        ema_model=ema_model,
+        variant_best=variant_best,
     )
-    epoch, best_val_f1, best_val_tail_recall = train_phase(
+    epoch, best_val_f1, best_val_tail_recall, variant_best = train_phase(
         "finetune",
         args.finetune_epochs,
         epoch,
@@ -233,18 +437,97 @@ def run_training_split(
         skip_finetune_until,
         **(tail_config or {}),
         best_val_tail_recall=best_val_tail_recall,
+        ema_model=ema_model,
+        variant_best=variant_best,
+    )
+
+    raw_path = output_dir / "best_raw.pt"
+    ema_path = output_dir / "best_ema.pt"
+    if not raw_path.exists():
+        raise RuntimeError(f"Training did not produce {raw_path}")
+    source_path = ema_path if ema_path.exists() else raw_path
+    source_checkpoint = torch.load(source_path, map_location=device, weights_only=False)
+    load_model_state_compat(model, source_checkpoint["model_state"])
+
+    lws_path = output_dir / "best_lws.pt"
+    if args.lws_epochs > 0:
+        train_lws_post_training(
+            model,
+            train_loader,
+            val_loader,
+            device,
+            args,
+            source_checkpoint,
+            lws_path,
+        )
+
+    variant_paths = [raw_path]
+    if ema_path.exists():
+        variant_paths.append(ema_path)
+    if lws_path.exists():
+        variant_paths.append(lws_path)
+
+    variant_results: dict[str, dict[str, Any]] = {}
+    deployment: tuple[float, Path, dict[str, Any], np.ndarray] | None = None
+    y_true: np.ndarray | None = None
+    for variant_path in variant_paths:
+        checkpoint = torch.load(variant_path, map_location=device, weights_only=False)
+        load_model_state_compat(model, checkpoint["model_state"])
+        variant = str(checkpoint.get("checkpoint_variant", variant_path.stem.removeprefix("best_")))
+        uncalibrated_y_true, uncalibrated_prob = predict_temperature(model, val_loader, device, 1.0)
+        uncalibrated_metrics, _, _ = compute_metrics(uncalibrated_y_true, uncalibrated_prob, class_names)
+        add_head_confidence_metrics(
+            uncalibrated_metrics,
+            uncalibrated_y_true,
+            uncalibrated_prob,
+            class_names,
+            train_df,
+        )
+        temperature = fit_global_temperature(model, val_loader, device) if args.fit_temperature else 1.0
+        current_y_true, current_prob = predict_temperature(model, val_loader, device, temperature)
+        current_metrics, current_per_class, current_cm = compute_metrics(current_y_true, current_prob, class_names)
+        add_head_confidence_metrics(current_metrics, current_y_true, current_prob, class_names, train_df)
+        checkpoint["temperature"] = temperature
+        checkpoint["uncalibrated_metrics"] = json_safe(uncalibrated_metrics)
+        checkpoint["temperature_metrics"] = json_safe(current_metrics)
+        checkpoint["checkpoint_variant"] = variant
+        torch.save(checkpoint, variant_path)
+        current_per_class.to_csv(output_dir / f"per_class_metrics_{variant}.csv", index=False)
+        pd.DataFrame(current_cm, index=class_names, columns=class_names).to_csv(
+            output_dir / f"confusion_matrix_{variant}.csv"
+        )
+        variant_output = output_dir / variant
+        variant_output.mkdir(exist_ok=True)
+        save_predictions(val_df, current_y_true, current_prob, class_names, variant_output)
+        variant_results[variant] = {
+            "checkpoint": str(variant_path),
+            "temperature": temperature,
+            "uncalibrated_metrics": uncalibrated_metrics,
+            "metrics": current_metrics,
+        }
+        score = float(current_metrics[args.selection_metric])
+        if deployment is None or score > deployment[0]:
+            deployment = (score, variant_path, checkpoint, current_prob)
+            y_true = current_y_true
+
+    if deployment is None or y_true is None:
+        raise RuntimeError("No deployable raw/EMA/LWS checkpoint was produced.")
+    _, deployment_path, deployment_checkpoint, y_prob = deployment
+    torch.save(deployment_checkpoint, output_dir / "best.pt")
+    print(
+        f"Selected deployment variant={deployment_checkpoint['checkpoint_variant']} "
+        f"from {deployment_path.name}, temperature={deployment_checkpoint['temperature']:.4f}"
     )
 
-    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)
+    add_head_confidence_metrics(metrics, y_true, y_prob, class_names, train_df)
     metrics = {
-        "best_selection_metric": float(best_val_f1),
+        "best_selection_metric": float(metrics[args.selection_metric]),
         "selection_metric_name": args.selection_metric,
-        "best_val_f1_macro": float(best_val_f1) if args.selection_metric == "f1_macro" else None,
+        "best_val_f1_macro": float(metrics["f1_macro"]),
+        "checkpoint_variant": deployment_checkpoint["checkpoint_variant"],
+        "temperature": deployment_checkpoint["temperature"],
+        "variants": variant_results,
         **metrics,
     }
     if tail_config is not None:
@@ -293,7 +576,7 @@ def run_training_split(
         fold,
     )
     print(
-        f"Done: best_val_f1_macro={best_val_f1:.4f}, "
+        f"Done: best_val_f1_macro={metrics['f1_macro']:.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']}"
@@ -318,14 +601,24 @@ def train_single_run(
         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)
+        train_sources = set(train_df["lesion_id"].astype(str))
+        val_sources = set(val_df["lesion_id"].astype(str))
+        synthetic_df["source_lesion_id"] = synthetic_df["lesion_id"].astype(str).map(source_lesion_id)
+        unknown_sources = ~synthetic_df["source_lesion_id"].isin(train_sources | val_sources)
+        if unknown_sources.any():
+            examples = synthetic_df.loc[unknown_sources, "lesion_id"].astype(str).head(5).tolist()
+            raise ValueError(f"Synthetic lesions have unknown source IDs. Examples: {examples}")
+        safe_synthetic_df = synthetic_df[synthetic_df["source_lesion_id"].isin(train_sources)].copy()
+        excluded_count = int(synthetic_df["source_lesion_id"].isin(val_sources).sum())
+        train_df = pd.concat([train_df, safe_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)}"
+            f"Source-safe synthetic train-only split: real_train={len(train_df) - len(safe_synthetic_df)}, "
+            f"synthetic_train={len(safe_synthetic_df)}, excluded_validation_sources={excluded_count}, "
+            f"val_real={len(val_df)}"
         )
     else:
         train_df, val_df = lesion_split(df, args.val_size, args.seed)
-    train_df = append_augmented_train_rows(df, train_df, class_names, args)
+    train_df = append_augmented_train_rows(df, train_df, val_df, class_names, args)
     return run_training_split(
         df,
         train_df,
@@ -355,7 +648,7 @@ def train_kfold(
     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}")
-        train_df = append_augmented_train_rows(df, train_df, class_names, args)
+        train_df = append_augmented_train_rows(df, train_df, val_df, class_names, args)
         metrics = run_training_split(
             df,
             train_df,

milk10k_effb2_metadata/training.py

@@ -7,17 +7,58 @@ import argparse
 from milk10k_effb2_metadata.training_utils import json_safe
 
 
+def validate_balance_args(args: argparse.Namespace) -> None:
+    if args.balance_mode == "hybrid" and args.weighted_sampler:
+        raise ValueError("--balance-mode hybrid cannot be combined with --weighted-sampler.")
+    if args.balance_head_ratio <= 0:
+        raise ValueError("--balance-head-ratio must be greater than 0.")
+    if args.balance_tail_floor < 0:
+        raise ValueError("--balance-tail-floor must be >= 0.")
+    if args.balance_min_source_count < 1:
+        raise ValueError("--balance-min-source-count must be at least 1.")
+    tau = float(getattr(args, "tau", 0.0))
+    class_weight = bool(getattr(args, "class_weight", False))
+    loss = str(getattr(args, "loss", "ce"))
+    lws_epochs = int(getattr(args, "lws_epochs", 0))
+    lws_lr = float(getattr(args, "lws_lr", 1e-2))
+    lws_sampler_power = float(getattr(args, "lws_sampler_power", 0.5))
+    lws_min_scale = float(getattr(args, "lws_min_scale", 0.75))
+    lws_max_scale = float(getattr(args, "lws_max_scale", 1.5))
+    ema_decay = float(getattr(args, "ema_decay", 0.999))
+    if not 0.0 <= tau <= 0.5:
+        raise ValueError("--tau must be between 0.0 and 0.5.")
+    if tau > 0.0 and class_weight:
+        raise ValueError("--tau > 0 cannot be combined with --class-weight.")
+    if tau > 0.0 and loss in {"focal", "ldam"}:
+        raise ValueError("--tau > 0 requires a CE-based loss (ce, ce_dice, or ce_f1).")
+    if lws_epochs < 0:
+        raise ValueError("--lws-epochs must be >= 0.")
+    if lws_lr <= 0.0:
+        raise ValueError("--lws-lr must be > 0.")
+    if not 0.0 <= lws_sampler_power <= 1.0:
+        raise ValueError("--lws-sampler-power must be between 0.0 and 1.0.")
+    if lws_min_scale <= 0.0 or lws_max_scale < lws_min_scale:
+        raise ValueError("LWS scale bounds must satisfy 0 < min <= max.")
+    if not 0.0 < ema_decay < 1.0:
+        raise ValueError("--ema-decay must be between 0 and 1.")
+
+
 def run(args: argparse.Namespace) -> None:
     import torch
 
     from datasets import resolve_data_dir, set_seed
-    from milk10k_effb2_metadata.data import load_paired_dataframe
+    from milk10k_effb2_metadata.data import (
+        audit_dermoscopic_masks,
+        load_paired_dataframe,
+        print_mask_audit_summary,
+    )
     from milk10k_effb2_metadata.model_setup import resolve_training_backbone_backends
     from milk10k_effb2_metadata.models import normalize_backbone_name, resolve_image_size
     from milk10k_effb2_metadata.runner import train_kfold, train_single_run
 
     if args.k_folds < 1:
         raise ValueError("--k-folds must be at least 1.")
+    validate_balance_args(args)
 
     set_seed(args.seed)
     data_dir = resolve_data_dir(args.data_dir)
@@ -31,6 +72,17 @@ def run(args: argparse.Namespace) -> None:
     args.image_size = resolve_image_size(args.backbone, args.image_size)
 
     df = load_paired_dataframe(data_dir)
+    if not 0.0 <= args.min_dermoscopic_mask_ratio <= 1.0:
+        raise ValueError("--min-dermoscopic-mask-ratio must be between 0 and 1.")
+    if args.dermoscopic_mask_dir is not None:
+        args.dermoscopic_mask_dir = args.dermoscopic_mask_dir.expanduser().resolve()
+        df, mask_audit = audit_dermoscopic_masks(
+            df,
+            args.dermoscopic_mask_dir,
+            args.min_dermoscopic_mask_ratio,
+        )
+        mask_audit.to_csv(args.output_dir / "dermoscopic_mask_audit.csv", index=False)
+        print_mask_audit_summary(mask_audit, args.min_dermoscopic_mask_ratio)
     class_names = sorted(df["label"].unique())
     label_to_idx = {label: idx for idx, label in enumerate(class_names)}
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

milk10k_effb2_metadata/training_utils.py

@@ -46,6 +46,7 @@ def save_run_config(
         "paths": {
             "output_dir": str(output_dir),
             "data_dir": str(getattr(args, "data_dir", "")),
+            "dermoscopic_mask_dir": str(getattr(args, "dermoscopic_mask_dir", "")),
             "clinical_checkpoint": str(getattr(args, "clinical_checkpoint", "")),
             "dermoscopic_checkpoint": str(getattr(args, "dermoscopic_checkpoint", "")),
             "resume_checkpoint": str(getattr(args, "resume_checkpoint", "")),