Upload 13 files

README.md

@@ -37,6 +37,15 @@ python train_milk10k_effb2_dermoscopic_metadata.py \
 Use `--encoder-checkpoint` to initialize only the image encoder and
 `--resume-checkpoint RUN/last.pt` to continue an interrupted run.
 
+Losses: `ce`, `focal`, `ldam`, `ce_dice`, and `ce_f1`. For generated datasets,
+use `--synthetic-train-only` so `__sdpair_` lesions cannot enter validation.
+Additional generated data can be appended with `--augmented-data-dir`, filtered
+with `--augmented-classes`, and capped with `--augmented-max-per-class`.
+
+Use `--selection-metric f1_macro` (default) or `dice_macro`. LDAM runs also
+write `tail_best.pt`. Pass `--k-folds N` to create deterministic folds in the
+shared split manifest.
+
 ## Inference
 
 ```bash
@@ -55,4 +64,6 @@ is loaded automatically unless `--no-auto-calibration` is passed.
 
 Training writes `best.pt`, `last.pt`, `history.csv`, `metrics.json`,
 `per_class_metrics.csv`, `confusion_matrix.csv`, `val_predictions.csv`,
-`train_split.csv`, `val_split.csv`, and `run_config.json`.
+`splits/`, `run_config.json`, `data_summary.json`, `split_summary.md`,
+prediction/confusion diagnostics, and `run_report.md`. K-fold runs additionally
+write `kfold_summary.csv/json` and `kfold_report.md`.

milk10k_effb2_dermoscopic_metadata/ablation.py

@@ -27,15 +27,24 @@ def summarize(output_dir: Path):
     payload = {"runs": {}, "delta_with_minus_without": {}}
     keys = ["f1_macro", "balanced_accuracy", "accuracy", "roc_auc_macro_ovr", "f1_weighted"]
     for mode, directory in runs.items():
-        metrics = json.loads((directory / "metrics.json").read_text(encoding="utf-8"))
+        if (directory / "metrics.json").exists():
+            metrics = json.loads((directory / "metrics.json").read_text(encoding="utf-8"))
+        else:
+            kfold = json.loads((directory / "kfold_summary.json").read_text(encoding="utf-8"))
+            metrics = kfold["mean"]
         payload["runs"][mode] = metrics
         rows.append({"metadata_mode": mode, **{key: metrics.get(key) for key in keys}})
     for key in keys:
         left = payload["runs"]["none"].get(key); right = payload["runs"]["concat"].get(key)
         payload["delta_with_minus_without"][key] = None if left is None or right is None else right - left
     class_rows = []
-    none_pc = pd.read_csv(runs["none"] / "per_class_metrics.csv").set_index("class")
-    with_pc = pd.read_csv(runs["concat"] / "per_class_metrics.csv").set_index("class")
+    def per_class(directory):
+        direct=directory/"per_class_metrics.csv"
+        paths=[direct] if direct.exists() else sorted(directory.glob("fold_*/per_class_metrics.csv"))
+        frames=[pd.read_csv(path) for path in paths]
+        if not frames:raise FileNotFoundError(f"No per-class metrics under {directory}")
+        return pd.concat(frames).groupby("class",as_index=True).mean(numeric_only=True)
+    none_pc = per_class(runs["none"]); with_pc = per_class(runs["concat"])
     for name in none_pc.index:
         class_rows.append({"class": name, "f1_no_metadata": none_pc.loc[name, "f1"], "f1_with_metadata": with_pc.loc[name, "f1"],
                            "f1_delta": with_pc.loc[name, "f1"] - none_pc.loc[name, "f1"],

milk10k_effb2_dermoscopic_metadata/core.py

@@ -15,7 +15,6 @@ from sklearn.metrics import (
     precision_recall_fscore_support, roc_auc_score,
 )
 from sklearn.preprocessing import label_binarize
-from torch import nn
 
 
 def set_seed(seed: int) -> None:
@@ -26,39 +25,6 @@ def set_seed(seed: int) -> None:
         torch.cuda.manual_seed_all(seed)
 
 
-class SoftDiceLoss(nn.Module):
-    def __init__(self, num_classes: int, smooth: float = 1.0):
-        super().__init__()
-        self.num_classes = num_classes
-        self.smooth = smooth
-
-    def forward(self, logits, labels):
-        probs = torch.softmax(logits, dim=1)
-        target = torch.nn.functional.one_hot(labels, self.num_classes).to(probs.dtype)
-        intersection = (probs * target).sum(dim=0)
-        denominator = probs.sum(dim=0) + target.sum(dim=0)
-        return 1.0 - ((2 * intersection + self.smooth) / (denominator + self.smooth)).mean()
-
-
-class CEDiceLoss(nn.Module):
-    def __init__(self, num_classes: int, dice_weight: float, class_weights: torch.Tensor | None = None):
-        super().__init__()
-        self.ce = nn.CrossEntropyLoss(weight=class_weights)
-        self.dice = SoftDiceLoss(num_classes)
-        self.dice_weight = dice_weight
-
-    def forward(self, logits, labels):
-        return (1.0 - self.dice_weight) * self.ce(logits, labels) + self.dice_weight * self.dice(logits, labels)
-
-
-def build_loss(loss_name: str, num_classes: int, dice_weight: float, class_weights=None):
-    if loss_name == "ce":
-        return nn.CrossEntropyLoss(weight=class_weights)
-    if loss_name == "ce_dice":
-        return CEDiceLoss(num_classes, dice_weight, class_weights)
-    raise ValueError(f"Unsupported loss: {loss_name}")
-
-
 def safe_auc(y_true_bin, y_prob, average):
     try:
         return float(roc_auc_score(y_true_bin, y_prob, average=average, multi_class="ovr"))
@@ -91,6 +57,7 @@ def compute_metrics(y_true: np.ndarray, y_prob: np.ndarray, class_names: list[st
     metrics = {
         "accuracy": float(accuracy_score(y_true, y_pred)),
         "balanced_accuracy": float(balanced_accuracy_score(y_true, y_pred)),
+        "top2_accuracy": float(np.mean((np.argsort(y_prob, axis=1)[:, -min(2, len(labels)):] == y_true[:, None]).any(axis=1))),
         "top3_accuracy": float(np.mean((np.argsort(y_prob, axis=1)[:, -min(3, len(labels)):] == y_true[:, None]).any(axis=1))),
         "precision_macro": float(macro[0]), "recall_macro": float(macro[1]), "f1_macro": float(macro[2]),
         "dice_macro": float(macro[2]),
@@ -111,9 +78,9 @@ def apply_class_bias(y_prob: np.ndarray, bias: np.ndarray) -> np.ndarray:
     return exp / exp.sum(axis=1, keepdims=True)
 
 
-def optimize_class_bias(y_true, y_prob, class_names, max_bias=1.5, step=0.25, passes=3):
+def optimize_class_bias(y_true, y_prob, class_names, max_bias=1.5, step=0.25, passes=3, metric_name="f1_macro"):
     bias = np.zeros(len(class_names), dtype=np.float32)
-    best = compute_metrics(y_true, y_prob, class_names)[0]["f1_macro"]
+    best = compute_metrics(y_true, y_prob, class_names)[0][metric_name]
     candidates = np.arange(-max_bias, max_bias + step / 2, step)
     for _ in range(passes):
         improved = False
@@ -121,7 +88,7 @@ def optimize_class_bias(y_true, y_prob, class_names, max_bias=1.5, step=0.25, pa
             local_best, local_value = best, bias[index]
             for value in candidates:
                 trial = bias.copy(); trial[index] = value
-                score = compute_metrics(y_true, apply_class_bias(y_prob, trial), class_names)[0]["f1_macro"]
+                score = compute_metrics(y_true, apply_class_bias(y_prob, trial), class_names)[0][metric_name]
                 if score > local_best:
                     local_best, local_value = score, float(value)
             if local_best > best:

milk10k_effb2_dermoscopic_metadata/data.py

@@ -10,7 +10,7 @@ import numpy as np
 import pandas as pd
 import torch
 from PIL import Image, ImageFile
-from sklearn.model_selection import train_test_split
+from sklearn.model_selection import StratifiedKFold, train_test_split
 from torch.utils.data import DataLoader, Dataset, WeightedRandomSampler
 from torchvision import transforms
 
@@ -105,13 +105,35 @@ def metadata_vector(row: pd.Series, spec: dict[str, Any]) -> np.ndarray:
     return np.asarray(values, dtype=np.float32)
 
 
-def create_or_load_split(df: pd.DataFrame, manifest: Path, val_size: float, seed: int) -> tuple[pd.DataFrame, pd.DataFrame]:
+def synthetic_mask(df: pd.DataFrame) -> np.ndarray:
+    mask = np.zeros(len(df), dtype=bool)
+    if "is_augmented" in df:
+        mask |= df["is_augmented"].fillna(False).astype(bool).to_numpy()
+    mask |= df["lesion_id"].astype(str).str.contains("__sdpair_", regex=False).to_numpy()
+    return mask
+
+
+def create_or_load_split(
+    df: pd.DataFrame, manifest: Path, val_size: float, seed: int,
+    synthetic_train_only: bool = False, fold_index: int = 0, k_folds: int = 1,
+) -> tuple[pd.DataFrame, pd.DataFrame]:
     manifest = manifest.expanduser().resolve()
     all_ids = set(df["lesion_id"].astype(str))
     if manifest.exists():
         payload = json.loads(manifest.read_text(encoding="utf-8"))
-        train_ids = set(map(str, payload["train_lesion_ids"]))
-        val_ids = set(map(str, payload["val_lesion_ids"]))
+        if "folds" in payload:
+            if int(payload.get("k_folds", 1)) != k_folds:
+                raise ValueError("Split manifest k_folds does not match --k-folds.")
+            if bool(payload.get("synthetic_train_only", False)) != synthetic_train_only:
+                raise ValueError("Split manifest synthetic_train_only does not match current CLI; use a separate manifest.")
+            try: selected = payload["folds"][fold_index]
+            except IndexError as exc: raise ValueError(f"Split manifest has no fold {fold_index}.") from exc
+            train_ids = set(map(str, selected["train_lesion_ids"])); val_ids = set(map(str, selected["val_lesion_ids"]))
+        else:  # v1 manifest compatibility
+            if k_folds != 1: raise ValueError("Legacy split manifest cannot be used with k-fold training.")
+            train_ids = set(map(str, payload["train_lesion_ids"])); val_ids = set(map(str, payload["val_lesion_ids"]))
+            if synthetic_train_only and any("__sdpair_" in item for item in val_ids):
+                raise ValueError("Legacy manifest contains synthetic validation IDs; remove it to create a safe v2 manifest.")
         if train_ids & val_ids:
             raise ValueError(f"Split manifest has overlapping train/validation IDs: {manifest}")
         unknown = (train_ids | val_ids) - all_ids
@@ -119,19 +141,31 @@ def create_or_load_split(df: pd.DataFrame, manifest: Path, val_size: float, seed
         if unknown or missing:
             raise ValueError(f"Split manifest does not match dataset (unknown={len(unknown)}, missing={len(missing)}).")
     else:
-        train_rows, val_rows = train_test_split(
-            df[["lesion_id", "label"]], test_size=val_size, stratify=df["label"], random_state=seed
-        )
-        train_ids = set(train_rows["lesion_id"].astype(str))
-        val_ids = set(val_rows["lesion_id"].astype(str))
+        synthetic = synthetic_mask(df)
+        base = df.loc[~synthetic].copy() if synthetic_train_only else df.copy()
+        extra_train_ids = set(df.loc[synthetic, "lesion_id"].astype(str)) if synthetic_train_only else set()
+        folds = []
+        if k_folds == 1:
+            train_rows, val_rows = train_test_split(base, test_size=val_size, stratify=base["label"], random_state=seed)
+            pairs = [(train_rows, val_rows)]
+        else:
+            if k_folds < 2: raise ValueError("--k-folds must be 1 or >=2.")
+            minimum = int(base["label"].value_counts().min())
+            if k_folds > minimum: raise ValueError(f"--k-folds={k_folds} exceeds smallest class count={minimum}.")
+            splitter = StratifiedKFold(k_folds, shuffle=True, random_state=seed)
+            pairs = [(base.iloc[tr], base.iloc[va]) for tr, va in splitter.split(base, base["label"])]
+        for train_rows, val_rows in pairs:
+            folds.append({
+                "train_lesion_ids": sorted(set(train_rows["lesion_id"].astype(str)) | extra_train_ids),
+                "val_lesion_ids": sorted(set(val_rows["lesion_id"].astype(str))),
+            })
+        train_ids = set(folds[fold_index]["train_lesion_ids"]); val_ids = set(folds[fold_index]["val_lesion_ids"])
         manifest.parent.mkdir(parents=True, exist_ok=True)
         manifest.write_text(
             json.dumps(
                 {
-                    "seed": seed,
-                    "val_size": val_size,
-                    "train_lesion_ids": sorted(train_ids),
-                    "val_lesion_ids": sorted(val_ids),
+                    "schema_version": 2, "seed": seed, "val_size": val_size, "k_folds": k_folds,
+                    "synthetic_train_only": synthetic_train_only, "folds": folds,
                 },
                 indent=2,
             ),
@@ -142,6 +176,22 @@ def create_or_load_split(df: pd.DataFrame, manifest: Path, val_size: float, seed
     return train_df.reset_index(drop=True), val_df.reset_index(drop=True)
 
 
+def append_augmented_rows(base_df: pd.DataFrame, train_df: pd.DataFrame, args) -> pd.DataFrame:
+    if args.augmented_data_dir is None: return train_df
+    augmented = load_dermoscopic_dataframe(args.augmented_data_dir)
+    augmented = augmented[~augmented["lesion_id"].astype(str).isin(set(base_df["lesion_id"].astype(str)))].copy()
+    if args.augmented_classes:
+        allowed = {name.upper() for name in args.augmented_classes}
+        unknown = allowed - {name.upper() for name in base_df["label"].unique()}
+        if unknown: raise ValueError(f"Unknown augmented classes: {sorted(unknown)}")
+        augmented = augmented[augmented["label"].str.upper().isin(allowed)]
+    if args.augmented_max_per_class < 0: raise ValueError("--augmented-max-per-class must be >=0.")
+    if args.augmented_max_per_class:
+        augmented = augmented.sample(frac=1, random_state=args.seed).groupby("label", group_keys=False).head(args.augmented_max_per_class)
+    augmented["is_augmented"] = True; augmented["ignore_metadata"] = bool(args.zero_augmented_metadata)
+    return pd.concat([train_df, augmented], ignore_index=True, sort=False)
+
+
 def make_transforms(image_size: int):
     normalize = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
     train_transform = transforms.Compose(
@@ -166,6 +216,8 @@ class DermoscopicMetadataDataset(Dataset):
         self.df = df.reset_index(drop=True)
         self.labels = None if label_to_idx is None or "label" not in df else [label_to_idx[x] for x in self.df["label"]]
         self.metadata = np.stack([metadata_vector(row, metadata_spec) for _, row in self.df.iterrows()])
+        if "ignore_metadata" in self.df:
+            self.metadata[self.df["ignore_metadata"].fillna(False).astype(bool).to_numpy()] = 0
         self.transform = transform
 
     def __len__(self) -> int:
@@ -193,7 +245,7 @@ def make_loaders(train_df, val_df, label_to_idx, metadata_spec, args):
         counts = np.bincount(labels, minlength=len(label_to_idx))
         if np.any(counts == 0):
             raise ValueError("Cannot use weighted sampler with an empty training class.")
-        weights = (1.0 / counts.astype(np.float64))[labels]
+        weights = (1.0 / np.power(counts.astype(np.float64), args.sampler_power))[labels]
         generator = torch.Generator().manual_seed(args.seed)
         sampler = WeightedRandomSampler(torch.as_tensor(weights, dtype=torch.double), len(labels), True, generator=generator)
     common = dict(batch_size=args.batch_size, num_workers=args.num_workers, pin_memory=torch.cuda.is_available())

milk10k_effb2_dermoscopic_metadata/inference.py

@@ -21,15 +21,18 @@ def parse_args(argv=None):
     parser = argparse.ArgumentParser(description="Predict with dermoscopic-only metadata checkpoints.")
     parser.add_argument("--checkpoint", type=Path, nargs="*", default=[])
     parser.add_argument("--checkpoint-dir", type=Path, default=None)
-    parser.add_argument("--input-dir", type=Path, required=True)
-    parser.add_argument("--metadata-csv", type=Path, required=True)
+    parser.add_argument("--data-dir", type=Path, default=None)
+    parser.add_argument("--input-dir", type=Path, default=None)
+    parser.add_argument("--metadata-csv", type=Path, default=None)
     parser.add_argument("--groundtruth-csv", type=Path, default=None)
     parser.add_argument("--output", type=Path, required=True)
     parser.add_argument("--batch-size", type=int, default=32)
     parser.add_argument("--num-workers", type=int, default=0)
     parser.add_argument("--image-size", type=int, default=None)
     parser.add_argument("--tta-flips", action="store_true")
+    parser.add_argument("--calibration-file", type=Path, default=None)
     parser.add_argument("--no-auto-calibration", action="store_true")
+    parser.add_argument("--include-debug-columns", action="store_true")
     return parser.parse_args(argv)
 
 
@@ -79,6 +82,7 @@ def build_model(checkpoint, device):
         len(checkpoint["class_names"]), input_dim, saved["metadata_mode"], saved.get("backbone", "efficientnet_b2"), False,
         int(saved.get("branch_dim", 512)), int(saved.get("metadata_dim", 64)), int(saved.get("classifier_hidden_dim", 512)),
         float(saved.get("dropout", 0.3)), checkpoint.get("backbone_backend_resolved", saved.get("backbone_backend", "timm")).replace("auto", "timm"),
+        saved.get("metadata_gate_hidden_dim"),
     ).to(device)
     model.load_state_dict(checkpoint["model_state"]); model.eval()
     return model
@@ -100,19 +104,27 @@ def predict(model, loader, device, tta):
 def run(args):
     paths = checkpoint_paths(args); device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     checkpoints = [torch.load(path, map_location=device, weights_only=False) for path in paths]
-    class_names = checkpoints[0]["class_names"]; spec = checkpoints[0]["metadata_spec"]
+    class_names = checkpoints[0]["class_names"]
     for checkpoint in checkpoints[1:]:
-        if checkpoint["class_names"] != class_names or checkpoint["metadata_spec"] != spec:
-            raise ValueError("Ensemble checkpoints have incompatible class names or metadata specs.")
+        if checkpoint["class_names"] != class_names:
+            raise ValueError("Ensemble checkpoints have incompatible class names.")
+    if args.data_dir is not None:
+        data_dir=args.data_dir.expanduser().resolve()
+        default_input=data_dir/"MILK10k_Training_Input"
+        if not default_input.exists():default_input=data_dir.parent/"MILK10k_Training_Input"
+        args.input_dir=args.input_dir or default_input
+        args.metadata_csv=args.metadata_csv or data_dir/"MILK10k_Training_Metadata.csv"
+        if args.groundtruth_csv is None and (data_dir/"MILK10k_Training_GroundTruth.csv").exists():args.groundtruth_csv=data_dir/"MILK10k_Training_GroundTruth.csv"
+    if args.input_dir is None or args.metadata_csv is None:raise ValueError("Pass --data-dir or both --input-dir and --metadata-csv.")
     df = load_dataframe(args.input_dir, args.metadata_csv, args.groundtruth_csv)
     size = args.image_size or int(checkpoints[0]["args"].get("image_size", 260))
     _, transform = make_transforms(size)
-    dataset = DermoscopicMetadataDataset(df, None, spec, transform)
-    loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers, pin_memory=torch.cuda.is_available())
     ensemble = []
     for path, checkpoint in zip(paths, checkpoints):
+        dataset = DermoscopicMetadataDataset(df, None, checkpoint["metadata_spec"], transform)
+        loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers, pin_memory=torch.cuda.is_available())
         probs = predict(build_model(checkpoint, device), loader, device, args.tta_flips)
-        calibration_path = path.parent / "calibration.json"
+        calibration_path = args.calibration_file.expanduser().resolve() if args.calibration_file else path.parent / "calibration.json"
         if not args.no_auto_calibration and calibration_path.exists():
             calibration = json.loads(calibration_path.read_text(encoding="utf-8"))
             if calibration["class_names"] != class_names:
@@ -120,7 +132,11 @@ def run(args):
             probs = apply_class_bias(probs, np.asarray(calibration["class_bias"], dtype=np.float32))
         ensemble.append(probs)
     y_prob = np.mean(ensemble, axis=0)
-    output = pd.DataFrame(y_prob, columns=class_names); output.insert(0, "lesion_id", df["lesion_id"])
+    output = pd.DataFrame(y_prob, columns=class_names)
+    if args.include_debug_columns:
+        output.insert(0,"confidence",y_prob.max(1));output.insert(0,"predicted_label",[class_names[i] for i in y_prob.argmax(1)])
+        if "isic_id" in df:output.insert(0,"isic_id",df["isic_id"].tolist())
+    output.insert(0, "lesion_id", df["lesion_id"].tolist())
     args.output.parent.mkdir(parents=True, exist_ok=True); output.to_csv(args.output, index=False)
     if "label" in df and df["label"].notna().all():
         mapping = {name: index for index, name in enumerate(class_names)}

milk10k_effb2_dermoscopic_metadata/losses.py

@@ -0,0 +1,111 @@
+"""Classification losses for the dermoscopic-only trainer."""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn.functional as F
+from sklearn.utils.class_weight import compute_class_weight
+from torch import nn
+
+
+class FocalLoss(nn.Module):
+    def __init__(self, weight=None, gamma=2.0):
+        super().__init__(); self.weight = weight; self.gamma = gamma
+
+    def forward(self, logits, labels):
+        ce = F.cross_entropy(logits, labels, reduction="none")
+        loss = (1.0 - torch.exp(-ce)) ** self.gamma * ce
+        if self.weight is not None: loss = loss * self.weight[labels]
+        return loss.mean()
+
+
+class LDAMLoss(nn.Module):
+    def __init__(self, class_counts, beta=.9999, max_margin=.5, deferred_start_epoch=0, alpha_max=10.0):
+        super().__init__()
+        counts = class_counts.float().clamp_min(1)
+        margins = 1.0 / torch.sqrt(torch.sqrt(counts)); margins *= max_margin / margins.max().clamp_min(1e-12)
+        alpha = effective_number_alpha(counts, beta).clamp(max=alpha_max); alpha *= counts.numel() / alpha.sum().clamp_min(1e-12)
+        self.register_buffer("margins", margins); self.register_buffer("alpha", alpha)
+        self.deferred_start_epoch = deferred_start_epoch; self.current_epoch = 0
+
+    def set_epoch(self, epoch): self.current_epoch = epoch
+
+    def forward(self, logits, labels):
+        adjusted = logits.clone(); rows = torch.arange(labels.size(0), device=labels.device)
+        adjusted[rows, labels] -= self.margins.to(logits)[labels]
+        loss = F.cross_entropy(adjusted, labels, reduction="none")
+        if self.current_epoch >= self.deferred_start_epoch: loss *= self.alpha.to(logits)[labels]
+        return loss.mean()
+
+
+class SoftMacroDiceLoss(nn.Module):
+    def forward(self, logits, labels):
+        probs = torch.softmax(logits, 1); target = F.one_hot(labels, logits.size(1)).to(probs.dtype)
+        score = (2 * (probs * target).sum(0) + 1e-6) / (probs.sum(0) + target.sum(0) + 1e-6)
+        return 1 - score.mean()
+
+
+class SoftMacroF1Loss(nn.Module):
+    def __init__(self, class_weights=None):
+        super().__init__()
+        if class_weights is not None: self.register_buffer("class_weights", class_weights.float())
+        else: self.class_weights = None
+
+    def forward(self, logits, labels):
+        probs = torch.softmax(logits, 1); target = F.one_hot(labels, logits.size(1)).to(probs.dtype)
+        tp = (probs * target).sum(0); fp = (probs * (1-target)).sum(0); fn = ((1-probs) * target).sum(0)
+        f1 = (2*tp + 1e-6) / (2*tp + fp + fn + 1e-6)
+        if self.class_weights is None: return 1 - f1.mean()
+        weights = self.class_weights.to(probs); return 1 - (f1 * weights).sum() / weights.sum().clamp_min(1e-6)
+
+
+class CompositeClassificationLoss(nn.Module):
+    def __init__(self, primary, auxiliary, weight):
+        super().__init__(); self.primary = primary; self.auxiliary = auxiliary; self.weight = weight
+    def forward(self, logits, labels): return self.primary(logits, labels) + self.weight * self.auxiliary(logits, labels)
+
+
+def effective_number_alpha(counts, beta):
+    if beta <= 0: return torch.ones_like(counts)
+    if beta >= 1: raise ValueError("--ldam-beta must be less than 1")
+    b = torch.tensor(beta, dtype=counts.dtype, device=counts.device)
+    return (1-b) / (1-torch.pow(b, counts)).clamp_min(1e-12)
+
+
+def class_counts(train_df, label_to_idx, device):
+    values = np.bincount([label_to_idx[x] for x in train_df.label], minlength=len(label_to_idx))
+    if np.any(values == 0): raise ValueError("Train split contains an empty class.")
+    return torch.tensor(values, dtype=torch.float32, device=device)
+
+
+def f1_weights(label_to_idx, args, device):
+    weights = torch.ones(len(label_to_idx), device=device)
+    normalized = {name.upper(): name for name in label_to_idx}
+    for name in args.f1_ignore_classes:
+        key = name.upper();
+        if key not in normalized: raise ValueError(f"Unknown F1 class: {name}")
+        weights[label_to_idx[normalized[key]]] = 0
+    for item in args.f1_class_weight:
+        if "=" not in item: raise ValueError(f"Expected CLASS=VALUE: {item}")
+        name, raw = item.split("=", 1); value = float(raw)
+        if value < 0 or name.upper() not in normalized: raise ValueError(f"Invalid F1 class weight: {item}")
+        weights[label_to_idx[normalized[name.upper()]]] = value
+    if weights.sum() <= 0: raise ValueError("F1 class weights sum to zero.")
+    return weights
+
+
+def build_loss(train_df: pd.DataFrame, label_to_idx, args, device):
+    if args.loss == "ldam":
+        return LDAMLoss(class_counts(train_df, label_to_idx, device), args.ldam_beta, args.ldam_max_margin,
+                        args.ldam_drw_start_epoch, args.ldam_alpha_max)
+    weight = None
+    if args.class_weight:
+        y = np.array([label_to_idx[x] for x in train_df.label])
+        weight = torch.tensor(compute_class_weight("balanced", classes=np.arange(len(label_to_idx)), y=y), dtype=torch.float32, device=device)
+    ce = nn.CrossEntropyLoss(weight=weight)
+    if args.loss == "focal": return FocalLoss(weight, args.focal_gamma)
+    if args.loss == "ce_dice": return CompositeClassificationLoss(ce, SoftMacroDiceLoss(), args.dice_weight)
+    if args.loss == "ce_f1": return CompositeClassificationLoss(ce, SoftMacroF1Loss(f1_weights(label_to_idx,args,device)), args.f1_weight)
+    return ce

milk10k_effb2_dermoscopic_metadata/model.py

@@ -52,6 +52,7 @@ class DermoscopicMetadataClassifier(nn.Module):
         self, num_classes: int, metadata_input_dim: int, metadata_mode: str = "none", backbone: str = "efficientnet_b2",
         imagenet_pretrained: bool = True, branch_dim: int = 512, metadata_dim: int = 64,
         classifier_hidden_dim: int = 512, dropout: float = 0.3, backbone_backend: str = "timm",
+        metadata_gate_hidden_dim: int | None = None,
     ):
         super().__init__()
         if metadata_mode not in METADATA_MODES:
@@ -68,9 +69,10 @@ class DermoscopicMetadataClassifier(nn.Module):
         else:
             self.metadata_head = MetadataHead(metadata_input_dim, metadata_dim, dropout)
             if metadata_mode in ("gated_concat", "gated_only"):
+                gate_hidden = metadata_gate_hidden_dim or metadata_dim
                 self.metadata_gate = nn.Sequential(
-                    nn.LayerNorm(metadata_input_dim), nn.Linear(metadata_input_dim, metadata_dim), nn.GELU(),
-                    nn.Linear(metadata_dim, branch_dim), nn.Sigmoid()
+                    nn.LayerNorm(metadata_input_dim), nn.Linear(metadata_input_dim, gate_hidden), nn.GELU(),
+                    nn.Linear(gate_hidden, branch_dim), nn.Sigmoid()
                 )
                 nn.init.zeros_(self.metadata_gate[-2].weight)
                 nn.init.constant_(self.metadata_gate[-2].bias, 2.0)
@@ -98,3 +100,9 @@ class DermoscopicMetadataClassifier(nn.Module):
 def set_encoder_trainable(model: DermoscopicMetadataClassifier, trainable: bool) -> None:
     for parameter in model.encoder.parameters():
         parameter.requires_grad = trainable
+
+
+def set_metadata_trainable(model: DermoscopicMetadataClassifier, trainable: bool) -> None:
+    for module in (model.metadata_head, model.metadata_gate):
+        if module is not None:
+            for parameter in module.parameters(): parameter.requires_grad = trainable

milk10k_effb2_dermoscopic_metadata/reporting.py

@@ -0,0 +1,92 @@
+"""Structured data, prediction, confusion, environment, and k-fold reports."""
+
+from __future__ import annotations
+
+import json, platform, subprocess, sys
+from datetime import datetime, timezone
+from pathlib import Path
+import numpy as np
+import pandas as pd
+from .core import json_safe
+from .data import synthetic_mask
+
+
+def environment_info():
+    import torch
+    def git(*args):
+        try: return subprocess.run(["git",*args],capture_output=True,text=True,timeout=5).stdout.strip()
+        except Exception: return None
+    return {"timestamp_utc":datetime.now(timezone.utc).isoformat(),"cwd":str(Path.cwd()),"command":sys.argv,
+            "python":sys.version.replace("\n"," "),"platform":platform.platform(),"executable":sys.executable,
+            "torch":{"version":torch.__version__,"cuda_available":torch.cuda.is_available(),
+                     "device":torch.cuda.get_device_name(0) if torch.cuda.is_available() else None},
+            "git":{"commit":git("rev-parse","HEAD"),"branch":git("rev-parse","--abbrev-ref","HEAD"),
+                   "status_short":(git("status","--short") or "").splitlines()}}
+
+
+def distribution(df, class_names):
+    synth = synthetic_mask(df); ignored = df.get("ignore_metadata",pd.Series(False,index=df.index)).fillna(False).astype(bool).to_numpy()
+    return {"rows":len(df),"real_rows":int((~synth).sum()),"synthetic_rows":int(synth.sum()),
+            "ignore_metadata_rows":int(ignored.sum()),
+            "class_counts":df.label.value_counts().reindex(class_names,fill_value=0).astype(int).to_dict(),
+            "synthetic_class_counts":df.loc[synth,"label"].value_counts().reindex(class_names,fill_value=0).astype(int).to_dict()}
+
+
+def save_data_summary(output_dir, full_df, train_df, val_df, class_names):
+    payload={"full":distribution(full_df,class_names),"train":distribution(train_df,class_names),"val":distribution(val_df,class_names),
+             "synthetic_train_only":bool(synthetic_mask(train_df).sum() and not synthetic_mask(val_df).sum())}
+    (output_dir/"data_summary.json").write_text(json.dumps(json_safe(payload),indent=2),encoding="utf-8")
+    lines=["# Split Summary",""]
+    for split in ("full","train","val"):
+        item=payload[split]; lines += [f"## {split.title()}","",f"- rows: {item['rows']}",f"- real: {item['real_rows']}",f"- synthetic: {item['synthetic_rows']}","","| class | count | synthetic |","|---|---:|---:|"]
+        lines += [f"| {name} | {count} | {item['synthetic_class_counts'][name]} |" for name,count in item["class_counts"].items()]; lines.append("")
+    (output_dir/"split_summary.md").write_text("\n".join(lines),encoding="utf-8")
+    return payload
+
+
+def prediction_summary(prob, class_names):
+    pred=prob.argmax(1); sorted_prob=np.sort(prob,axis=1); confidence=sorted_prob[:,-1]; second=sorted_prob[:,-2]
+    entropy=-np.sum(prob*np.log(np.clip(prob,1e-12,1)),axis=1); counts=np.bincount(pred,minlength=len(class_names))
+    return {"rows":len(prob),"predicted_class_counts":{n:int(counts[i]) for i,n in enumerate(class_names)},
+            "mean_probability":{n:float(prob[:,i].mean()) for i,n in enumerate(class_names)},
+            "mean_confidence":float(confidence.mean()),"median_confidence":float(np.median(confidence)),
+            "mean_top1_top2_gap":float((confidence-second).mean()),"mean_entropy":float(entropy.mean()),
+            "low_confidence_rows":int((confidence<.5).sum())}
+
+
+def confusion_analysis(cm,class_names):
+    pairs=[]
+    for i,true in enumerate(class_names):
+        total=int(cm[i].sum())
+        for j,pred in enumerate(class_names):
+            if i!=j and cm[i,j]: pairs.append({"true":true,"predicted":pred,"count":int(cm[i,j]),"rate_of_true":float(cm[i,j]/total) if total else 0})
+    return {"top_confusion_pairs":sorted(pairs,key=lambda x:x["count"],reverse=True)[:20]}
+
+
+def save_diagnostics(output_dir,args,data_summary,metrics,per_class,cm,prob,class_names,fold=None):
+    pred=prediction_summary(prob,class_names); conf=confusion_analysis(cm,class_names); warnings=[]
+    for row in per_class.to_dict("records"):
+        if row["support"]<=5: warnings.append({"severity":"medium","code":"tiny_validation_support","class":row["class"]})
+        if row["recall_sensitivity"]==0: warnings.append({"severity":"high","code":"zero_recall","class":row["class"]})
+    diag={"fold":fold,"warnings":warnings,"prediction_summary":pred,"confusion_analysis":conf}
+    for name,value in (("prediction_summary",pred),("confusion_analysis",conf),("run_diagnostics",diag)):
+        (output_dir/f"{name}.json").write_text(json.dumps(json_safe(value),indent=2),encoding="utf-8")
+    lines=["# Dermoscopic Run Report","",f"- fold: {fold}",f"- backbone: {args.backbone}",f"- metadata_mode: {args.metadata_mode}",f"- loss: {args.loss}","","## Metrics",""]
+    lines += [f"- {key}: {metrics.get(key)}" for key in ("accuracy","balanced_accuracy","f1_macro","dice_macro","roc_auc_macro_ovr","top3_accuracy")]
+    lines += ["","## Per class","","```",per_class.to_string(index=False),"```","","## Top confusions",""]
+    lines += [f"- {x['true']} -> {x['predicted']}: {x['count']} ({x['rate_of_true']:.1%})" for x in conf["top_confusion_pairs"][:12]]
+    lines += ["","## Warnings",""]+[f"- [{x['severity']}] {x['code']}: {x.get('class','')}" for x in warnings]
+    (output_dir/"run_report.md").write_text("\n".join(lines),encoding="utf-8")
+    return diag
+
+
+def save_kfold_summary(metrics_list,output_dir):
+    keys=("best_selection_metric","best_val_tail_recall_macro","accuracy","balanced_accuracy","f1_macro","f1_weighted","dice_macro","roc_auc_macro_ovr","top3_accuracy")
+    rows=[{"fold":i,**{k:m.get(k) for k in keys}} for i,m in enumerate(metrics_list)]
+    frame=pd.DataFrame(rows); frame.to_csv(output_dir/"kfold_summary.csv",index=False)
+    payload={"folds":rows,"mean":{},"std":{}}
+    for key in keys:
+        values=pd.to_numeric(frame[key],errors="coerce").dropna(); payload["mean"][key]=None if values.empty else float(values.mean()); payload["std"][key]=None if values.empty else float(values.std(ddof=0))
+    (output_dir/"kfold_summary.json").write_text(json.dumps(json_safe(payload),indent=2),encoding="utf-8")
+    (output_dir/"kfold_report.md").write_text("# K-fold Summary\n\n```\n"+frame.to_string(index=False)+"\n```\n",encoding="utf-8")
+    return payload

milk10k_effb2_dermoscopic_metadata/training.py

@@ -1,256 +1,244 @@
-"""Training CLI for the dermoscopic-only metadata classifier."""
+"""Training orchestration for single-dermoscopic-image metadata models."""
 
 from __future__ import annotations
 
-import argparse
-import json
+import argparse, json
 from pathlib import Path
-
 import numpy as np
 import pandas as pd
 import torch
-from sklearn.metrics import balanced_accuracy_score, precision_recall_fscore_support
+from sklearn.metrics import balanced_accuracy_score, confusion_matrix, precision_recall_fscore_support
 from torch.amp import GradScaler, autocast
 from tqdm.auto import tqdm
 
-from .core import apply_class_bias, build_loss, json_safe, optimize_class_bias, save_evaluation, set_seed
-from .data import create_or_load_split, fit_metadata_spec, load_dermoscopic_dataframe, make_loaders, metadata_vector
-from .model import DermoscopicMetadataClassifier, METADATA_MODES, set_encoder_trainable
-
-
-def parse_args(argv=None):
-    parser = argparse.ArgumentParser(description="Train an EfficientNet dermoscopic-only classifier with optional metadata.")
-    parser.add_argument("--data-dir", type=Path, required=True)
-    parser.add_argument("--input-dir", type=Path, default=None, help="Optional image root; defaults to data-dir or its parent/MILK10k_Training_Input.")
-    parser.add_argument("--output-dir", type=Path, required=True)
-    parser.add_argument("--split-manifest", type=Path, required=True, help="Shared JSON split; created once and reused exactly.")
-    parser.add_argument("--metadata-mode", choices=METADATA_MODES, default="none")
-    parser.add_argument("--backbone", default="efficientnet_b2")
-    parser.add_argument("--backbone-backend", choices=["auto", "timm", "torchvision"], default="auto")
-    parser.add_argument("--encoder-checkpoint", type=Path, default=None)
-    parser.add_argument("--resume-checkpoint", type=Path, default=None)
-    parser.add_argument("--image-size", type=int, default=260)
-    parser.add_argument("--batch-size", type=int, default=16)
-    parser.add_argument("--num-workers", type=int, default=0)
-    parser.add_argument("--freeze-epochs", type=int, default=5)
-    parser.add_argument("--finetune-epochs", type=int, default=20)
-    parser.add_argument("--head-lr", type=float, default=1e-4)
-    parser.add_argument("--encoder-lr", type=float, default=1e-5)
-    parser.add_argument("--weight-decay", type=float, default=1e-4)
-    parser.add_argument("--branch-dim", type=int, default=512)
-    parser.add_argument("--metadata-dim", type=int, default=64)
-    parser.add_argument("--classifier-hidden-dim", type=int, default=512)
-    parser.add_argument("--dropout", type=float, default=0.3)
-    parser.add_argument("--loss", choices=["ce", "ce_dice"], default="ce")
-    parser.add_argument("--dice-weight", type=float, default=0.3)
-    parser.add_argument("--class-weight", action="store_true")
-    parser.add_argument("--weighted-sampler", action="store_true")
-    parser.add_argument("--amp", action="store_true")
-    parser.add_argument("--val-size", type=float, default=0.2)
-    parser.add_argument("--seed", type=int, default=42)
-    parser.add_argument("--patience", type=int, default=6)
-    parser.add_argument("--calibrate-bias", action="store_true")
-    parser.add_argument("--calibration-max-bias", type=float, default=1.5)
-    parser.add_argument("--calibration-step", type=float, default=0.25)
-    parser.add_argument("--calibration-passes", type=int, default=3)
-    return parser.parse_args(argv)
+from .core import apply_class_bias, compute_metrics, json_safe, optimize_class_bias, save_evaluation, set_seed
+from .data import (append_augmented_rows, create_or_load_split, fit_metadata_spec, load_dermoscopic_dataframe,
+                   make_loaders, metadata_vector, synthetic_mask)
+from .losses import build_loss
+from .model import DermoscopicMetadataClassifier, METADATA_MODES, set_encoder_trainable, set_metadata_trainable
+from .reporting import environment_info, save_data_summary, save_diagnostics, save_kfold_summary
 
+CHECKPOINT_SCHEMA_VERSION = 2
 
-def class_weight_tensor(train_df, class_names, device):
-    counts = train_df["label"].value_counts().reindex(class_names, fill_value=0).to_numpy(dtype=np.float64)
-    if np.any(counts == 0):
-        raise ValueError("Cannot calculate class weights with an empty training class.")
-    weights = len(train_df) / (len(class_names) * counts)
-    return torch.tensor(weights, dtype=torch.float32, device=device)
 
-
-def load_encoder_checkpoint(path: Path, encoder, device):
-    payload = torch.load(path.expanduser().resolve(), map_location=device, weights_only=False)
-    state = payload.get("model_state", payload.get("model_state_dict", payload.get("state_dict", payload)))
-    prefixes = ("module.", "_orig_mod.", "model.", "encoder.", "dermoscopic_encoder.", "backbone.")
-    target = encoder.state_dict(); matched = {}
-    for raw_key, value in state.items():
-        variants = {raw_key}; key = raw_key
-        changed = True
+def parse_args(argv=None):
+    p=argparse.ArgumentParser(description="Train a dermoscopic-only classifier with optional metadata.")
+    p.add_argument("--data-dir",type=Path,required=True); p.add_argument("--input-dir",type=Path,default=None)
+    p.add_argument("--output-dir",type=Path,required=True); p.add_argument("--split-manifest",type=Path,required=True)
+    p.add_argument("--metadata-mode",choices=METADATA_MODES,default="none"); p.add_argument("--backbone",default="efficientnet_b2")
+    p.add_argument("--backbone-backend",choices=["auto","timm","torchvision"],default="auto")
+    p.add_argument("--encoder-checkpoint",type=Path,default=None); p.add_argument("--resume-checkpoint",type=Path,default=None)
+    p.add_argument("--imagenet-pretrained",action="store_true")
+    p.add_argument("--image-size",type=int,default=260); p.add_argument("--batch-size",type=int,default=16); p.add_argument("--num-workers",type=int,default=0)
+    p.add_argument("--freeze-epochs",type=int,default=5); p.add_argument("--finetune-epochs",type=int,default=20)
+    p.add_argument("--head-lr",type=float,default=1e-4); p.add_argument("--encoder-lr",type=float,default=1e-5); p.add_argument("--metadata-lr",type=float,default=None)
+    p.add_argument("--weight-decay",type=float,default=1e-4); p.add_argument("--branch-dim",type=int,default=512); p.add_argument("--metadata-dim",type=int,default=64)
+    p.add_argument("--metadata-gate-hidden-dim",type=int,default=None); p.add_argument("--freeze-metadata-head",action="store_true")
+    p.add_argument("--classifier-hidden-dim",type=int,default=512); p.add_argument("--dropout",type=float,default=.3)
+    p.add_argument("--loss",choices=["ce","focal","ldam","ce_dice","ce_f1"],default="ce")
+    p.add_argument("--focal-gamma",type=float,default=2.0); p.add_argument("--dice-weight",type=float,default=.3); p.add_argument("--f1-weight",type=float,default=.3)
+    p.add_argument("--f1-ignore-classes",nargs="*",default=[]); p.add_argument("--f1-class-weight",action="append",default=[])
+    p.add_argument("--ldam-beta",type=float,default=.9999); p.add_argument("--ldam-max-margin",type=float,default=.5)
+    p.add_argument("--ldam-drw-start-epoch",type=int,default=0); p.add_argument("--ldam-alpha-max",type=float,default=10.0); p.add_argument("--tail-num-classes",type=int,default=4)
+    p.add_argument("--class-weight",action="store_true"); p.add_argument("--weighted-sampler",action="store_true"); p.add_argument("--sampler-power",type=float,default=1.0)
+    p.add_argument("--synthetic-train-only",action="store_true"); p.add_argument("--augmented-data-dir",type=Path,default=None)
+    p.add_argument("--augmented-max-per-class",type=int,default=0); p.add_argument("--augmented-classes",nargs="*",default=[]); p.add_argument("--zero-augmented-metadata",action="store_true")
+    p.add_argument("--k-folds",type=int,default=1); p.add_argument("--val-size",type=float,default=.2); p.add_argument("--seed",type=int,default=42)
+    p.add_argument("--amp",action="store_true"); p.add_argument("--patience",type=int,default=6)
+    p.add_argument("--selection-metric",choices=["f1_macro","dice_macro"],default="f1_macro")
+    p.add_argument("--calibrate-bias",action="store_true"); p.add_argument("--calibration-metric",choices=["f1_macro","dice_macro"],default="dice_macro")
+    p.add_argument("--calibration-max-bias",type=float,default=1.5); p.add_argument("--calibration-step",type=float,default=.25); p.add_argument("--calibration-passes",type=int,default=3)
+    return p.parse_args(argv)
+
+
+def extract_state(payload): return payload.get("model_state",payload.get("model_state_dict",payload.get("state_dict",payload)))
+
+
+def infer_checkpoint_backend(path,device):
+    keys=list(extract_state(torch.load(path.expanduser().resolve(),map_location=device,weights_only=False)))
+    normalized=[]
+    for key in keys:
+        changed=True
         while changed:
-            changed = False
-            for prefix in prefixes:
-                if key.startswith(prefix):
-                    key = key.removeprefix(prefix); variants.add(key); changed = True; break
-        for candidate in variants:
-            if candidate in target and tuple(target[candidate].shape) == tuple(value.shape):
-                matched[candidate] = value; break
-    if not matched:
-        raise RuntimeError(f"No compatible encoder weights found in {path}")
-    target.update(matched); encoder.load_state_dict(target)
-    print(f"Loaded {len(matched)} encoder keys from {path}; skipped={len(state) - len(matched)}")
-
-
-def infer_checkpoint_backend(path: Path, device) -> str:
-    payload = torch.load(path.expanduser().resolve(), map_location=device, weights_only=False)
-    state = payload.get("model_state", payload.get("model_state_dict", payload.get("state_dict", payload)))
-    keys = []
-    for key in state:
-        for prefix in ("module.", "model.", "_orig_mod.", "encoder.", "dermoscopic_encoder."):
-            key = key.removeprefix(prefix)
-        keys.append(key)
-    timm_hits = sum(key.startswith(("conv_stem.", "blocks.", "conv_head.", "stages.", "stem.")) for key in keys)
-    torchvision_hits = sum(key.startswith(("features.", "avgpool.", "classifier.")) for key in keys)
-    if timm_hits > torchvision_hits: return "timm"
-    if torchvision_hits > timm_hits: return "torchvision"
-    raise RuntimeError(f"Cannot infer backbone backend from {path}; pass --backbone-backend explicitly.")
-
-
-def make_optimizer(model, args, encoder_trainable):
-    encoder = [p for p in model.encoder.parameters() if p.requires_grad]
-    head = [p for name, p in model.named_parameters() if not name.startswith("encoder.") and p.requires_grad]
-    groups = [{"params": head, "lr": args.head_lr}]
-    if encoder_trainable and encoder:
-        groups.append({"params": encoder, "lr": args.encoder_lr})
-    return torch.optim.AdamW(groups, weight_decay=args.weight_decay)
-
-
-def run_epoch(model, loader, criterion, device, optimizer=None, use_amp=False):
-    training = optimizer is not None
-    model.train(training)
-    scaler = GradScaler("cuda", enabled=training and use_amp)
-    total_loss = total = correct = 0
-    y_true, y_pred = [], []
-    for batch in tqdm(loader, leave=False):
-        image = batch["image"].to(device, non_blocking=True)
-        metadata = batch["metadata"].to(device, non_blocking=True)
-        labels = batch["label"].to(device, non_blocking=True)
-        if training:
-            optimizer.zero_grad(set_to_none=True)
+            changed=False
+            for prefix in ("module.","model.","_orig_mod.","encoder.","dermoscopic_encoder."):
+                if key.startswith(prefix): key=key.removeprefix(prefix); changed=True; break
+        normalized.append(key)
+    timm=sum(k.startswith(("conv_stem.","blocks.","conv_head.","stages.","stem.")) for k in normalized)
+    tv=sum(k.startswith(("features.","avgpool.","classifier.")) for k in normalized)
+    if timm>tv:return "timm"
+    if tv>timm:return "torchvision"
+    raise RuntimeError(f"Cannot infer backend from {path}; pass --backbone-backend.")
+
+
+def load_encoder_checkpoint(path,encoder,device):
+    state=extract_state(torch.load(path.expanduser().resolve(),map_location=device,weights_only=False)); target=encoder.state_dict(); matched={}
+    for raw,value in state.items():
+        key=raw; changed=True
+        while changed:
+            changed=False
+            for prefix in ("module.","_orig_mod.","model.","encoder.","dermoscopic_encoder.","backbone."):
+                if key.startswith(prefix): key=key.removeprefix(prefix); changed=True; break
+        if key in target and tuple(target[key].shape)==tuple(value.shape): matched[key]=value
+    if not matched: raise RuntimeError(f"No compatible encoder weights in {path}")
+    target.update(matched); encoder.load_state_dict(target); print(f"Loaded encoder keys={len(matched)}, skipped={len(state)-len(matched)}")
+
+
+def make_optimizer(model,args,encoder_trainable):
+    encoder=[]; metadata=[]; head=[]
+    for name,param in model.named_parameters():
+        if not param.requires_grad: continue
+        if name.startswith("encoder."): encoder.append(param)
+        elif name.startswith(("metadata_head.","metadata_gate.")): metadata.append(param)
+        else: head.append(param)
+    groups=[{"params":head,"lr":args.head_lr}]
+    if metadata: groups.append({"params":metadata,"lr":args.metadata_lr or args.head_lr})
+    if encoder_trainable and encoder: groups.append({"params":encoder,"lr":args.encoder_lr})
+    return torch.optim.AdamW(groups,weight_decay=args.weight_decay)
+
+
+def metric_key(name): return "".join(x if x.isalnum() else "_" for x in name)
+
+
+def run_epoch(model,loader,criterion,device,optimizer=None,scaler=None,use_amp=False,class_names=None,tail_indices=None):
+    training=optimizer is not None; model.train(training); total_loss=total=correct=top3=0; truths=[]; preds=[]
+    for batch in tqdm(loader,leave=False):
+        image=batch["image"].to(device,non_blocking=True); metadata=batch["metadata"].to(device,non_blocking=True); labels=batch["label"].to(device,non_blocking=True)
+        if training: optimizer.zero_grad(set_to_none=True)
         with torch.set_grad_enabled(training):
-            with autocast(device.type, enabled=use_amp):
-                logits = model(image, metadata)
-                loss = criterion(logits, labels)
+            with autocast(device.type,enabled=use_amp): logits=model(image,metadata); loss=criterion(logits,labels)
             if training:
-                scaler.scale(loss).backward()
-                scaler.unscale_(optimizer)
-                torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
-                scaler.step(optimizer)
-                scaler.update()
-        size = labels.size(0)
-        total_loss += float(loss.detach()) * size; total += size
-        predicted = logits.argmax(1)
-        correct += int((predicted == labels).sum())
-        y_true.append(labels.detach().cpu().numpy()); y_pred.append(predicted.detach().cpu().numpy())
-    truth = np.concatenate(y_true); pred = np.concatenate(y_pred)
-    f1 = precision_recall_fscore_support(truth, pred, average="macro", zero_division=0)[2]
-    return {"loss": total_loss / total, "accuracy": correct / total, "balanced_accuracy": float(balanced_accuracy_score(truth, pred)), "f1_macro": float(f1)}
+                assert scaler is not None; scaler.scale(loss).backward(); scaler.unscale_(optimizer); torch.nn.utils.clip_grad_norm_(model.parameters(),1.0); scaler.step(optimizer); scaler.update()
+        size=labels.size(0); total_loss+=float(loss.detach())*size; total+=size; predicted=logits.argmax(1); correct+=int((predicted==labels).sum())
+        top3+=int(logits.topk(min(3,logits.size(1)),1).indices.eq(labels[:,None]).any(1).sum()); truths.append(labels.cpu().numpy()); preds.append(predicted.cpu().numpy())
+    y=np.concatenate(truths); pred=np.concatenate(preds); labels=list(range(len(class_names or [])))
+    precision,recall,f1,support=precision_recall_fscore_support(y,pred,labels=labels,zero_division=0); cm=confusion_matrix(y,pred,labels=labels)
+    stats={"loss":total_loss/max(total,1),"accuracy":correct/max(total,1),"balanced_accuracy":float(balanced_accuracy_score(y,pred)),
+           "f1_macro":float(f1.mean()),"dice_macro":float(f1.mean()),"top3_accuracy":top3/max(total,1)}
+    for i,name in enumerate(class_names or []):
+        key=metric_key(name); stats.update({f"support_{key}":float(support[i]),f"precision_{key}":float(precision[i]),f"recall_{key}":float(recall[i]),f"f1_{key}":float(f1[i]),f"correct_{key}":float(cm[i,i])})
+        row_total=int(cm[i].sum())
+        for j,pred_name in enumerate(class_names or []):
+            if i!=j and cm[i,j]: stats[f"conf_{key}_to_{metric_key(pred_name)}_count"]=float(cm[i,j]); stats[f"conf_{key}_to_{metric_key(pred_name)}_rate"]=float(cm[i,j]/row_total)
+    if tail_indices: stats["tail_recall_macro"]=float(recall[tail_indices].mean())
+    return stats
 
 
 @torch.no_grad()
-def predict(model, loader, device):
-    model.eval(); labels = []; probabilities = []
-    for batch in tqdm(loader, leave=False):
-        logits = model(batch["image"].to(device), batch["metadata"].to(device))
-        labels.append(batch["label"].numpy()); probabilities.append(torch.softmax(logits, 1).cpu().numpy())
-    return np.concatenate(labels), np.concatenate(probabilities)
-
-
-def checkpoint_payload(model, optimizer, epoch, phase, best, class_names, label_to_idx, metadata_spec, args):
-    return {
-        "epoch": epoch, "phase": phase, "best_val_f1_macro": best, "model_type": model.__class__.__name__,
-        "model_state": model.state_dict(), "optimizer_state": optimizer.state_dict(), "class_names": class_names,
-        "label_to_idx": label_to_idx, "metadata_spec": metadata_spec, "args": json_safe(vars(args)),
-    }
-
-
-def run(args):
-    if args.freeze_epochs + args.finetune_epochs <= 0:
-        raise ValueError("At least one training epoch is required.")
-    set_seed(args.seed)
-    output_dir = args.output_dir.expanduser().resolve(); output_dir.mkdir(parents=True, exist_ok=True)
-    df = load_dermoscopic_dataframe(args.data_dir, args.input_dir)
-    train_df, val_df = create_or_load_split(df, args.split_manifest, args.val_size, args.seed)
-    class_names = sorted(df["label"].unique()); label_to_idx = {name: i for i, name in enumerate(class_names)}
-    metadata_spec = fit_metadata_spec(train_df)
-    metadata_input_dim = len(metadata_vector(train_df.iloc[0], metadata_spec))
-    train_loader, val_loader = make_loaders(train_df, val_df, label_to_idx, metadata_spec, args)
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    if args.backbone_backend == "auto":
-        if args.resume_checkpoint:
-            resume_header = torch.load(args.resume_checkpoint.expanduser().resolve(), map_location="cpu", weights_only=False)
-            backbone_backend = resume_header.get("args", {}).get("backbone_backend", "timm")
-            backbone_backend = "timm" if backbone_backend == "auto" else backbone_backend
-        elif args.encoder_checkpoint:
-            backbone_backend = infer_checkpoint_backend(args.encoder_checkpoint, device)
-        else:
-            backbone_backend = "timm"
-    else:
-        backbone_backend = args.backbone_backend
-    args.backbone_backend = backbone_backend
-
-    model = DermoscopicMetadataClassifier(
-        len(class_names), metadata_input_dim, args.metadata_mode, args.backbone,
-        args.encoder_checkpoint is None and args.resume_checkpoint is None,
-        args.branch_dim, args.metadata_dim, args.classifier_hidden_dim, args.dropout, backbone_backend,
-    ).to(device)
-    start_epoch, best = 1, float("-inf")
+def predict(model,loader,device):
+    model.eval(); truth=[]; probs=[]
+    for batch in tqdm(loader,leave=False):
+        logits=model(batch["image"].to(device),batch["metadata"].to(device)); truth.append(batch["label"].numpy()); probs.append(torch.softmax(logits,1).cpu().numpy())
+    return np.concatenate(truth),np.concatenate(probs)
+
+
+def checkpoint_payload(model,optimizer,scheduler,scaler,epoch,phase,best,best_tail,patience,class_names,label_to_idx,spec,args):
+    return {"schema_version":CHECKPOINT_SCHEMA_VERSION,"epoch":epoch,"phase":phase,"best_val_f1_macro":best if args.selection_metric=="f1_macro" else None,
+            "best_selection_metric":best,"selection_metric_name":args.selection_metric,"best_val_tail_recall_macro":best_tail,"patience_count":patience,
+            "model_type":model.__class__.__name__,"model_state":model.state_dict(),"optimizer_state":optimizer.state_dict(),"scheduler_state":scheduler.state_dict(),
+            "scaler_state":scaler.state_dict(),"class_names":class_names,"label_to_idx":label_to_idx,"metadata_spec":spec,"args":json_safe(vars(args))}
+
+
+def tail_config(train_df,class_names,label_to_idx,args):
+    if args.loss!="ldam" or args.tail_num_classes<=0:return [],[]
+    counts=train_df.label.value_counts().reindex(class_names,fill_value=0); names=sorted(class_names,key=lambda x:(counts[x],x))[:args.tail_num_classes]
+    return names,[label_to_idx[x] for x in names]
+
+
+def train_split(base_df,train_df,val_df,class_names,label_to_idx,args,device,backend,output_dir,fold=None):
+    output_dir.mkdir(parents=True,exist_ok=True); split_dir=output_dir/"splits"; split_dir.mkdir(exist_ok=True)
+    train_df=append_augmented_rows(base_df,train_df,args); train_df["is_augmented"]=synthetic_mask(train_df); train_df["ignore_metadata"]=train_df.get("ignore_metadata",False)
+    val_df["is_augmented"]=synthetic_mask(val_df); val_df["ignore_metadata"]=False
+    train_df.to_csv(split_dir/"train.csv",index=False); val_df.to_csv(split_dir/"val.csv",index=False)
+    full_summary=pd.concat([train_df,val_df],ignore_index=True,sort=False); data_summary=save_data_summary(output_dir,full_summary,train_df,val_df,class_names)
+    spec=fit_metadata_spec(train_df); metadata_input_dim=len(metadata_vector(train_df.iloc[0],spec)); train_loader,val_loader=make_loaders(train_df,val_df,label_to_idx,spec,args)
+    model=DermoscopicMetadataClassifier(len(class_names),metadata_input_dim,args.metadata_mode,args.backbone,
+        args.imagenet_pretrained or (args.encoder_checkpoint is None and args.resume_checkpoint is None),args.branch_dim,args.metadata_dim,
+        args.classifier_hidden_dim,args.dropout,backend,args.metadata_gate_hidden_dim).to(device)
+    if args.freeze_metadata_head:set_metadata_trainable(model,False)
+    resume=None
     if args.resume_checkpoint:
-        resume = torch.load(args.resume_checkpoint.expanduser().resolve(), map_location=device, weights_only=False)
-        model.load_state_dict(resume["model_state"])
-        start_epoch = int(resume.get("epoch", 0)) + 1; best = float(resume.get("best_val_f1_macro", best))
-    elif args.encoder_checkpoint:
-        load_encoder_checkpoint(args.encoder_checkpoint, model.encoder, device)
-
-    train_df.to_csv(output_dir / "train_split.csv", index=False); val_df.to_csv(output_dir / "val_split.csv", index=False)
-    config = {"args": json_safe(vars(args)), "class_names": class_names, "label_to_idx": label_to_idx, "metadata_spec": metadata_spec,
-              "metadata_input_dim": metadata_input_dim, "backbone_backend_resolved": backbone_backend,
-              "train_size": len(train_df), "val_size": len(val_df)}
-    (output_dir / "run_config.json").write_text(json.dumps(config, indent=2), encoding="utf-8")
-
-    weights = class_weight_tensor(train_df, class_names, device) if args.class_weight else None
-    criterion = build_loss(args.loss, len(class_names), args.dice_weight, weights)
-    history = []
-    history_path = output_dir / "history.csv"
-    if history_path.exists() and args.resume_checkpoint:
-        history = pd.read_csv(history_path).to_dict("records")
-    global_epoch = 0
-    for phase, count, encoder_trainable in (("freeze", args.freeze_epochs, False), ("finetune", args.finetune_epochs, True)):
-        set_encoder_trainable(model, encoder_trainable)
-        optimizer = make_optimizer(model, args, encoder_trainable)
-        scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode="max", factor=0.2, patience=2)
-        patience = 0
-        for _ in range(count):
-            global_epoch += 1
-            if global_epoch < start_epoch:
-                continue
-            train_stats = run_epoch(model, train_loader, criterion, device, optimizer, args.amp and device.type == "cuda")
-            val_stats = run_epoch(model, val_loader, criterion, device, None, args.amp and device.type == "cuda")
-            scheduler.step(val_stats["f1_macro"])
-            row = {"phase": phase, "epoch": global_epoch, **{f"train_{k}": v for k, v in train_stats.items()}, **{f"val_{k}": v for k, v in val_stats.items()}}
-            history.append(row); pd.DataFrame(history).to_csv(history_path, index=False)
-            torch.save(checkpoint_payload(model, optimizer, global_epoch, phase, best, class_names, label_to_idx, metadata_spec, args), output_dir / "last.pt")
-            if val_stats["f1_macro"] > best:
-                best = val_stats["f1_macro"]; patience = 0
-                torch.save(checkpoint_payload(model, optimizer, global_epoch, phase, best, class_names, label_to_idx, metadata_spec, args), output_dir / "best.pt")
-            else:
-                patience += 1
-            print(f"{phase} epoch={global_epoch:03d} train_f1={train_stats['f1_macro']:.4f} val_f1={val_stats['f1_macro']:.4f}")
-            if args.patience > 0 and patience >= args.patience:
-                print(f"Early stopping {phase} after {patience} epochs without improvement."); break
-
-    best_checkpoint = torch.load(output_dir / "best.pt", map_location=device, weights_only=False)
-    model.load_state_dict(best_checkpoint["model_state"])
-    y_true, y_prob = predict(model, val_loader, device)
-    metrics = save_evaluation(output_dir, y_true, y_prob, val_df, class_names)
-    metrics["best_val_f1_macro"] = best
-    (output_dir / "metrics.json").write_text(json.dumps(json_safe(metrics), indent=2), encoding="utf-8")
+        resume=torch.load(args.resume_checkpoint.expanduser().resolve(),map_location=device,weights_only=False); model.load_state_dict(resume["model_state"])
+    elif args.encoder_checkpoint:load_encoder_checkpoint(args.encoder_checkpoint,model.encoder,device)
+    config={"args":json_safe(vars(args)),"environment":environment_info(),"class_names":class_names,"label_to_idx":label_to_idx,"metadata_spec":spec,
+            "metadata_input_dim":metadata_input_dim,"model_type":model.__class__.__name__,"backbone_backend_resolved":backend,"train_size":len(train_df),"val_size":len(val_df),"fold":fold}
+    (output_dir/"run_config.json").write_text(json.dumps(config,indent=2),encoding="utf-8")
+    criterion=build_loss(train_df,label_to_idx,args,device); tail_names,tail_indices=tail_config(train_df,class_names,label_to_idx,args)
+    history=[]; history_path=output_dir/"history.csv"
+    if resume is not None and history_path.exists():history=pd.read_csv(history_path).to_dict("records")
+    best=float(resume.get("best_selection_metric",resume.get("best_val_f1_macro",float("-inf")))) if resume else float("-inf")
+    best_tail=float(resume.get("best_val_tail_recall_macro",float("-inf"))) if resume else float("-inf")
+    resume_epoch=int(resume.get("epoch",0)) if resume else 0; resume_phase=resume.get("phase") if resume else None
+    phases=(("freeze",args.freeze_epochs,False,1),("finetune",args.finetune_epochs,True,args.freeze_epochs+1))
+    for phase,count,encoder_trainable,start in phases:
+        if count<=0:continue
+        end=start+count-1
+        if resume and ((resume_phase=="finetune" and phase=="freeze") or resume_epoch>=end):continue
+        set_encoder_trainable(model,encoder_trainable); optimizer=make_optimizer(model,args,encoder_trainable)
+        scheduler=torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer,mode="max",factor=.2,patience=2); scaler=GradScaler("cuda",enabled=args.amp and device.type=="cuda")
+        patience=int(resume.get("patience_count",0)) if resume and resume_phase==phase else 0
+        if resume and resume_phase==phase:
+            try:
+                optimizer.load_state_dict(resume["optimizer_state"])
+                if "scheduler_state" in resume:scheduler.load_state_dict(resume["scheduler_state"])
+                if "scaler_state" in resume:scaler.load_state_dict(resume["scaler_state"])
+            except (ValueError,KeyError) as exc:print(f"Resume state fallback to recreated optimizer/scaler: {exc}")
+        for epoch in range(max(start,resume_epoch+1),end+1):
+            if hasattr(criterion,"set_epoch"):criterion.set_epoch(epoch)
+            train_stats=run_epoch(model,train_loader,criterion,device,optimizer,scaler,args.amp and device.type=="cuda",class_names,tail_indices)
+            val_stats=run_epoch(model,val_loader,criterion,device,None,None,args.amp and device.type=="cuda",class_names,tail_indices); scheduler.step(val_stats[args.selection_metric])
+            history.append({"phase":phase,"epoch":epoch,**{f"train_{k}":v for k,v in train_stats.items()},**{f"val_{k}":v for k,v in val_stats.items()}}); pd.DataFrame(history).to_csv(history_path,index=False)
+            improved=val_stats[args.selection_metric]>best
+            if improved:best=val_stats[args.selection_metric];patience=0
+            else:patience+=1
+            tail_improved=bool(tail_indices and val_stats["tail_recall_macro"]>best_tail)
+            if tail_improved:best_tail=val_stats["tail_recall_macro"]
+            payload=checkpoint_payload(model,optimizer,scheduler,scaler,epoch,phase,best,best_tail,patience,class_names,label_to_idx,spec,args)
+            if improved:torch.save(payload,output_dir/"best.pt")
+            if tail_improved:payload.update({"tail_class_names":tail_names,"tail_class_indices":tail_indices});torch.save(payload,output_dir/"tail_best.pt")
+            torch.save(payload,output_dir/"last.pt")
+            print(f"{phase} epoch={epoch:03d} train_loss={train_stats['loss']:.4f} val_loss={val_stats['loss']:.4f} val_acc={val_stats['accuracy']:.4f} val_bal={val_stats['balanced_accuracy']:.4f} val_f1={val_stats['f1_macro']:.4f} val_top3={val_stats['top3_accuracy']:.4f}")
+            if tail_indices:print(f"tail={tail_names} val_tail_recall={val_stats['tail_recall_macro']:.4f}")
+            if args.patience>0 and patience>=args.patience:print(f"Early stopping {phase} at epoch {epoch}");break
+    best_path=output_dir/"best.pt"
+    if not best_path.exists():raise RuntimeError("No best checkpoint was produced.")
+    best_checkpoint=torch.load(best_path,map_location=device,weights_only=False);model.load_state_dict(best_checkpoint["model_state"])
+    y_true,y_prob=predict(model,val_loader,device);metrics,per_class,cm=compute_metrics(y_true,y_prob,class_names)
+    metrics={"best_selection_metric":best,"selection_metric_name":args.selection_metric,"best_val_f1_macro":best if args.selection_metric=="f1_macro" else None,
+             "best_val_tail_recall_macro":None if best_tail==float("-inf") else best_tail,"fold":fold,**metrics}
+    save_evaluation(output_dir,y_true,y_prob,val_df,class_names);(output_dir/"metrics.json").write_text(json.dumps(json_safe(metrics),indent=2),encoding="utf-8")
     if args.calibrate_bias:
-        bias, score = optimize_class_bias(y_true, y_prob, class_names, args.calibration_max_bias, args.calibration_step, args.calibration_passes)
-        calibration = {"class_names": class_names, "class_bias": bias.tolist(), "raw_f1_macro": metrics["f1_macro"], "calibrated_f1_macro": score}
-        (output_dir / "calibration.json").write_text(json.dumps(calibration, indent=2), encoding="utf-8")
-        save_evaluation(output_dir, y_true, apply_class_bias(y_prob, bias), val_df, class_names, prefix="calibrated")
-    print(f"Finished: output={output_dir}, val_f1_macro={metrics['f1_macro']:.4f}")
-
+        bias,score=optimize_class_bias(y_true,y_prob,class_names,args.calibration_max_bias,args.calibration_step,args.calibration_passes,args.calibration_metric)
+        calibrated=apply_class_bias(y_prob,bias); calibrated_metrics=save_evaluation(output_dir,y_true,calibrated,val_df,class_names,"calibrated")
+        (output_dir/"calibration.json").write_text(json.dumps({"metric":args.calibration_metric,"optimized_score":score,"class_names":class_names,"class_bias":bias.tolist(),"metrics":calibrated_metrics},indent=2),encoding="utf-8")
+        metrics["calibrated"]=calibrated_metrics;(output_dir/"metrics.json").write_text(json.dumps(json_safe(metrics),indent=2),encoding="utf-8")
+    save_diagnostics(output_dir,args,data_summary,metrics,per_class,cm,y_prob,class_names,fold)
+    return metrics
 
-def main():
-    run(parse_args())
 
-
-if __name__ == "__main__":
-    main()
+def run(args):
+    if args.freeze_epochs+args.finetune_epochs<=0:raise ValueError("At least one epoch is required.")
+    if args.k_folds<1:raise ValueError("--k-folds must be >=1.")
+    if args.k_folds>1 and args.resume_checkpoint:raise ValueError("Resume a specific fold directly; root k-fold resume is unsupported.")
+    set_seed(args.seed);args.output_dir=args.output_dir.expanduser().resolve();args.output_dir.mkdir(parents=True,exist_ok=True)
+    df=load_dermoscopic_dataframe(args.data_dir,args.input_dir);df["is_augmented"]=synthetic_mask(df);df["ignore_metadata"]=False
+    class_names=sorted(df.label.unique());label_to_idx={x:i for i,x in enumerate(class_names)};device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    if args.backbone_backend=="auto":
+        if args.resume_checkpoint:
+            saved=torch.load(args.resume_checkpoint,map_location="cpu",weights_only=False).get("args",{});backend=saved.get("backbone_backend","timm");backend="timm" if backend=="auto" else backend
+        elif args.encoder_checkpoint:backend=infer_checkpoint_backend(args.encoder_checkpoint,device)
+        else:backend="timm"
+    else:backend=args.backbone_backend
+    args.backbone_backend=backend
+    results=[]
+    for fold in range(args.k_folds):
+        train_df,val_df=create_or_load_split(df,args.split_manifest,args.val_size,args.seed,args.synthetic_train_only,fold,args.k_folds)
+        if args.synthetic_train_only and synthetic_mask(val_df).any():raise RuntimeError("Synthetic leakage detected in validation split.")
+        output=args.output_dir if args.k_folds==1 else args.output_dir/f"fold_{fold:02d}"
+        results.append(train_split(df,train_df,val_df,class_names,label_to_idx,args,device,backend,output,None if args.k_folds==1 else fold))
+    if args.k_folds>1:save_kfold_summary(results,args.output_dir)
+    return results[0] if args.k_folds==1 else results
+
+
+def main():run(parse_args())
+if __name__=="__main__":main()