Upload 9 files

milk10k_effb2_dermoscopic_metadata/__init__.py

@@ -0,0 +1,3 @@
+"""MILK10k single-dermoscopic-image classifier with optional metadata."""
+
+__version__ = "0.1.0"

milk10k_effb2_dermoscopic_metadata/ablation.py

@@ -0,0 +1,78 @@
+"""Run and summarize matched no-metadata vs metadata training."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import pandas as pd
+
+from .training import parse_args as parse_training_args, run as run_training
+
+
+def parse_args(argv=None):
+    parser = argparse.ArgumentParser(description="Run matched dermoscopic metadata ablation.")
+    parser.add_argument("--data-dir", type=Path, required=True)
+    parser.add_argument("--input-dir", type=Path, default=None)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    parser.add_argument("--split-manifest", type=Path, required=True)
+    parser.add_argument("training_args", nargs=argparse.REMAINDER, help="Extra training arguments after --, e.g. -- --amp --loss ce_dice")
+    return parser.parse_args(argv)
+
+
+def summarize(output_dir: Path):
+    runs = {"none": output_dir / "no_metadata", "concat": output_dir / "with_metadata"}
+    rows = []
+    payload = {"runs": {}, "delta_with_minus_without": {}}
+    keys = ["f1_macro", "balanced_accuracy", "accuracy", "roc_auc_macro_ovr", "f1_weighted"]
+    for mode, directory in runs.items():
+        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 = []
+    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"],
+                           "recall_delta": with_pc.loc[name, "recall_sensitivity"] - none_pc.loc[name, "recall_sensitivity"]})
+    pd.DataFrame(rows).to_csv(output_dir / "ablation_summary.csv", index=False)
+    pd.DataFrame(class_rows).to_csv(output_dir / "ablation_per_class.csv", index=False)
+    (output_dir / "ablation_summary.json").write_text(json.dumps(payload, indent=2), encoding="utf-8")
+
+
+def run(args):
+    output_dir = args.output_dir.expanduser().resolve(); output_dir.mkdir(parents=True, exist_ok=True)
+    extras = args.training_args[1:] if args.training_args[:1] == ["--"] else args.training_args
+    forbidden = {"--data-dir", "--input-dir", "--output-dir", "--split-manifest", "--metadata-mode", "--calibrate-bias"}
+    if forbidden.intersection(extras):
+        raise ValueError(f"Do not override ablation-controlled arguments: {sorted(forbidden.intersection(extras))}")
+    for mode, name in (("none", "no_metadata"), ("concat", "with_metadata")):
+        cli = ["--data-dir", str(args.data_dir), "--output-dir", str(output_dir / name), "--split-manifest", str(args.split_manifest), "--metadata-mode", mode]
+        if args.input_dir is not None:
+            cli.extend(["--input-dir", str(args.input_dir)])
+        cli.extend(extras)
+        run_training(parse_training_args(cli))
+    summarize(output_dir)
+    print(f"Ablation summary saved under {output_dir}")
+
+
+def main():
+    run(parse_args())
+
+
+if __name__ == "__main__":
+    main()

milk10k_effb2_dermoscopic_metadata/core.py

@@ -0,0 +1,120 @@
+"""Losses, prediction metrics, calibration, and serialization helpers."""
+
+from __future__ import annotations
+
+import json
+import random
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+import torch
+from sklearn.metrics import (
+    accuracy_score, balanced_accuracy_score, classification_report, confusion_matrix,
+    precision_recall_fscore_support, roc_auc_score,
+)
+from sklearn.preprocessing import label_binarize
+
+
+def set_seed(seed: int) -> None:
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+
+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"))
+    except ValueError:
+        return None
+
+
+def compute_metrics(y_true: np.ndarray, y_prob: np.ndarray, class_names: list[str]):
+    y_pred = y_prob.argmax(axis=1)
+    labels = list(range(len(class_names)))
+    cm = confusion_matrix(y_true, y_pred, labels=labels)
+    precision, recall, f1, support = precision_recall_fscore_support(y_true, y_pred, labels=labels, zero_division=0)
+    total = int(cm.sum())
+    rows = []
+    for idx, name in enumerate(class_names):
+        tp = int(cm[idx, idx]); fn = int(cm[idx].sum() - tp); fp = int(cm[:, idx].sum() - tp); tn = total - tp - fn - fp
+        binary = (y_true == idx).astype(np.int64)
+        try:
+            auc = float(roc_auc_score(binary, y_prob[:, idx]))
+        except ValueError:
+            auc = None
+        rows.append({
+            "class": name, "support": int(support[idx]), "precision": float(precision[idx]),
+            "recall_sensitivity": float(recall[idx]), "specificity": tn / (tn + fp) if tn + fp else 0.0,
+            "f1": float(f1[idx]), "auc_ovr": auc,
+        })
+    macro = precision_recall_fscore_support(y_true, y_pred, labels=labels, average="macro", zero_division=0)
+    weighted = precision_recall_fscore_support(y_true, y_pred, labels=labels, average="weighted", zero_division=0)
+    y_true_bin = label_binarize(y_true, classes=labels)
+    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]),
+        "precision_weighted": float(weighted[0]), "recall_weighted": float(weighted[1]), "f1_weighted": float(weighted[2]),
+        "roc_auc_macro_ovr": safe_auc(y_true_bin, y_prob, "macro"),
+        "roc_auc_weighted_ovr": safe_auc(y_true_bin, y_prob, "weighted"),
+        "specificity_macro": float(np.mean([row["specificity"] for row in rows])),
+        "per_class": rows,
+        "classification_report": classification_report(y_true, y_pred, labels=labels, target_names=class_names, zero_division=0, output_dict=True),
+    }
+    return metrics, pd.DataFrame(rows), cm
+
+
+def apply_class_bias(y_prob: np.ndarray, bias: np.ndarray) -> np.ndarray:
+    logits = np.log(np.clip(y_prob, 1e-12, 1.0)) + bias[None, :]
+    logits -= logits.max(axis=1, keepdims=True)
+    exp = np.exp(logits)
+    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, metric_name="f1_macro"):
+    bias = np.zeros(len(class_names), dtype=np.float32)
+    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
+        for index in range(len(class_names)):
+            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][metric_name]
+                if score > local_best:
+                    local_best, local_value = score, float(value)
+            if local_best > best:
+                bias[index], best, improved = local_value, local_best, True
+        if not improved:
+            break
+    return bias, float(best)
+
+
+def json_safe(value: Any):
+    if isinstance(value, Path): return str(value)
+    if isinstance(value, np.generic): return value.item()
+    if isinstance(value, np.ndarray): return value.tolist()
+    if isinstance(value, dict): return {str(k): json_safe(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)): return [json_safe(v) for v in value]
+    return value
+
+
+def save_evaluation(output_dir: Path, y_true, y_prob, df, class_names, prefix=""):
+    metrics, per_class, cm = compute_metrics(y_true, y_prob, class_names)
+    stem = f"{prefix}_" if prefix else ""
+    (output_dir / f"{stem}metrics.json").write_text(json.dumps(json_safe(metrics), indent=2), encoding="utf-8")
+    per_class.to_csv(output_dir / f"{stem}per_class_metrics.csv", index=False)
+    pd.DataFrame(cm, index=class_names, columns=class_names).to_csv(output_dir / f"{stem}confusion_matrix.csv")
+    predictions = pd.DataFrame(y_prob, columns=class_names)
+    predictions.insert(0, "true_label", [class_names[i] for i in y_true])
+    predictions.insert(0, "lesion_id", df["lesion_id"].tolist())
+    predictions.to_csv(output_dir / f"{stem}val_predictions.csv", index=False)
+    return metrics

milk10k_effb2_dermoscopic_metadata/data.py

@@ -0,0 +1,255 @@
+"""Dermoscopic-only dataframe, metadata, split, transform, and loader helpers."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+import torch
+from PIL import Image, ImageFile
+from sklearn.model_selection import StratifiedKFold, train_test_split
+from torch.utils.data import DataLoader, Dataset, WeightedRandomSampler
+from torchvision import transforms
+
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+LABEL_COLUMNS = ["AKIEC", "BCC", "BEN_OTH", "BKL", "DF", "INF", "MAL_OTH", "MEL", "NV", "SCCKA", "VASC"]
+BASE_METADATA_COLUMNS = ("age_approx", "sex", "skin_tone_class", "site")
+
+
+def normalize_image_type(value: str) -> str:
+    return str(value).strip().lower().replace(" ", "_").replace(":", "").replace("-", "_")
+
+
+def resolve_training_paths(data_dir: Path, input_dir: Path | None = None) -> tuple[Path, Path, Path]:
+    data_dir = data_dir.expanduser().resolve()
+    if input_dir is None:
+        local_input = data_dir / "MILK10k_Training_Input"
+        sibling_input = data_dir.parent / "MILK10k_Training_Input"
+        input_dir = local_input if local_input.exists() else sibling_input
+    else:
+        input_dir = input_dir.expanduser().resolve()
+    metadata_csv = data_dir / "MILK10k_Training_Metadata.csv"
+    groundtruth_csv = data_dir / "MILK10k_Training_GroundTruth.csv"
+    missing = [path for path in (input_dir, metadata_csv, groundtruth_csv) if not path.exists()]
+    if missing:
+        raise FileNotFoundError("Missing MILK10k training input: " + ", ".join(map(str, missing)))
+    return input_dir, metadata_csv, groundtruth_csv
+
+
+def resolve_monet_columns(meta: pd.DataFrame) -> list[str]:
+    return sorted(column for column in meta.columns if column.startswith("MONET_"))
+
+
+def load_dermoscopic_dataframe(data_dir: Path, input_dir: Path | None = None) -> pd.DataFrame:
+    input_dir, metadata_csv, groundtruth_csv = resolve_training_paths(data_dir, input_dir)
+    meta = pd.read_csv(metadata_csv)
+    gt = pd.read_csv(groundtruth_csv)
+    required = {"lesion_id", "isic_id", "image_type", *BASE_METADATA_COLUMNS}
+    missing = required.difference(meta.columns)
+    if missing:
+        raise ValueError(f"Metadata CSV is missing columns: {sorted(missing)}")
+    label_columns = [column for column in LABEL_COLUMNS if column in gt.columns]
+    if not label_columns:
+        raise ValueError("Ground-truth CSV contains no recognized class columns.")
+
+    meta["image_type_norm"] = meta["image_type"].map(normalize_image_type)
+    dermoscopic = meta[meta["image_type_norm"] == "dermoscopic"].copy()
+    duplicate_counts = dermoscopic.groupby("lesion_id").size()
+    duplicates = duplicate_counts[duplicate_counts > 1]
+    if not duplicates.empty:
+        sample = duplicates.head(5).to_dict()
+        raise ValueError(f"Expected one dermoscopic image per lesion; duplicates found: {sample}")
+    dermoscopic["image_path"] = dermoscopic.apply(
+        lambda row: input_dir / str(row["lesion_id"]) / f"{row['isic_id']}.jpg", axis=1
+    )
+    dermoscopic = dermoscopic[dermoscopic["image_path"].map(Path.exists)].copy()
+    dermoscopic["image_path"] = dermoscopic["image_path"].map(str)
+
+    gt = gt.copy()
+    gt["label"] = gt[label_columns].idxmax(axis=1)
+    df = gt[["lesion_id", "label"]].merge(dermoscopic, on="lesion_id", how="inner", validate="one_to_one")
+    if df.empty:
+        raise ValueError(f"No labeled dermoscopic images found under {input_dir}")
+    return df.reset_index(drop=True)
+
+
+def fit_metadata_spec(train_df: pd.DataFrame) -> dict[str, Any]:
+    def categories(column: str) -> list[str]:
+        values = train_df[column].fillna("unknown").astype(str).str.strip().replace("", "unknown")
+        return sorted(set(values.tolist()) | {"unknown"})
+
+    return {
+        "sex_values": categories("sex"),
+        "site_values": categories("site"),
+        "monet_columns": resolve_monet_columns(train_df),
+    }
+
+
+def metadata_vector(row: pd.Series, spec: dict[str, Any]) -> np.ndarray:
+    age = pd.to_numeric(row.get("age_approx"), errors="coerce")
+    skin = pd.to_numeric(row.get("skin_tone_class"), errors="coerce")
+    sex = str(row.get("sex", "unknown")).strip() if pd.notna(row.get("sex")) else "unknown"
+    site = str(row.get("site", "unknown")).strip() if pd.notna(row.get("site")) else "unknown"
+    sex = sex or "unknown"
+    site = site or "unknown"
+    values = [0.0 if pd.isna(age) else float(age) / 100.0, 0.0 if pd.isna(skin) else float(skin) / 6.0]
+    values.extend(float(sex == item) for item in spec["sex_values"])
+    values.extend(float(site == item) for item in spec["site_values"])
+    for column in spec.get("monet_columns", []):
+        value = pd.to_numeric(row.get(column), errors="coerce")
+        values.append(0.0 if pd.isna(value) else float(value))
+    return np.asarray(values, dtype=np.float32)
+
+
+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"))
+        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
+        missing = all_ids - (train_ids | val_ids)
+        if unknown or missing:
+            raise ValueError(f"Split manifest does not match dataset (unknown={len(unknown)}, missing={len(missing)}).")
+    else:
+        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(
+                {
+                    "schema_version": 2, "seed": seed, "val_size": val_size, "k_folds": k_folds,
+                    "synthetic_train_only": synthetic_train_only, "folds": folds,
+                },
+                indent=2,
+            ),
+            encoding="utf-8",
+        )
+    train_df = df[df["lesion_id"].astype(str).isin(train_ids)].copy()
+    val_df = df[df["lesion_id"].astype(str).isin(val_ids)].copy()
+    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(
+        [
+            transforms.RandomResizedCrop(image_size, scale=(0.75, 1.0)),
+            transforms.RandomHorizontalFlip(),
+            transforms.RandomVerticalFlip(),
+            transforms.RandomRotation(20),
+            transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
+            transforms.ToTensor(),
+            normalize,
+        ]
+    )
+    eval_transform = transforms.Compose(
+        [transforms.Resize(round(image_size * 1.12)), transforms.CenterCrop(image_size), transforms.ToTensor(), normalize]
+    )
+    return train_transform, eval_transform
+
+
+class DermoscopicMetadataDataset(Dataset):
+    def __init__(self, df: pd.DataFrame, label_to_idx: dict[str, int] | None, metadata_spec: dict[str, Any], transform=None):
+        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:
+        return len(self.df)
+
+    def __getitem__(self, index: int) -> dict[str, torch.Tensor]:
+        row = self.df.iloc[index]
+        with Image.open(row["image_path"]) as source:
+            image = source.convert("RGB")
+        if self.transform:
+            image = self.transform(image)
+        item = {"image": image, "metadata": torch.from_numpy(self.metadata[index])}
+        if self.labels is not None:
+            item["label"] = torch.tensor(self.labels[index], dtype=torch.long)
+        return item
+
+
+def make_loaders(train_df, val_df, label_to_idx, metadata_spec, args):
+    train_transform, eval_transform = make_transforms(args.image_size)
+    train_ds = DermoscopicMetadataDataset(train_df, label_to_idx, metadata_spec, train_transform)
+    val_ds = DermoscopicMetadataDataset(val_df, label_to_idx, metadata_spec, eval_transform)
+    sampler = None
+    if args.weighted_sampler:
+        labels = np.asarray(train_ds.labels)
+        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 / 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())
+    return (
+        DataLoader(train_ds, shuffle=sampler is None, sampler=sampler, **common),
+        DataLoader(val_ds, shuffle=False, **common),
+    )

milk10k_effb2_dermoscopic_metadata/inference.py

@@ -0,0 +1,156 @@
+"""Inference for dermoscopic-only metadata checkpoints."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+from torch.utils.data import DataLoader
+from tqdm.auto import tqdm
+
+from .core import apply_class_bias, compute_metrics, json_safe
+from .data import BASE_METADATA_COLUMNS, DermoscopicMetadataDataset, LABEL_COLUMNS, make_transforms, normalize_image_type, resolve_monet_columns
+from .model import DermoscopicMetadataClassifier
+
+
+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("--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)
+
+
+def checkpoint_paths(args):
+    paths = [path.expanduser().resolve() for path in args.checkpoint]
+    if args.checkpoint_dir:
+        directory = args.checkpoint_dir.expanduser().resolve()
+        folds = sorted(directory.glob("fold_*/best.pt"))
+        paths.extend(folds or ([directory / "best.pt"] if (directory / "best.pt").exists() else []))
+    if not paths:
+        raise ValueError("Pass --checkpoint or --checkpoint-dir containing best.pt.")
+    missing = [path for path in paths if not path.exists()]
+    if missing:
+        raise FileNotFoundError(f"Missing checkpoints: {missing}")
+    return paths
+
+
+def load_dataframe(input_dir: Path, metadata_csv: Path, groundtruth_csv: Path | None):
+    input_dir = input_dir.expanduser().resolve()
+    meta = pd.read_csv(metadata_csv.expanduser().resolve())
+    required = {"lesion_id", "isic_id", "image_type", *BASE_METADATA_COLUMNS}
+    missing = required - set(meta.columns)
+    if missing:
+        raise ValueError(f"Metadata CSV is missing columns: {sorted(missing)}")
+    meta["image_type_norm"] = meta["image_type"].map(normalize_image_type)
+    df = meta[meta["image_type_norm"] == "dermoscopic"].copy()
+    duplicates = df.groupby("lesion_id").size()
+    if (duplicates > 1).any():
+        raise ValueError("Expected exactly one dermoscopic row per lesion.")
+    df["image_path"] = df.apply(lambda row: input_dir / str(row["lesion_id"]) / f"{row['isic_id']}.jpg", axis=1)
+    df = df[df["image_path"].map(Path.exists)].copy(); df["image_path"] = df["image_path"].map(str)
+    if groundtruth_csv and groundtruth_csv.exists():
+        gt = pd.read_csv(groundtruth_csv)
+        columns = [name for name in LABEL_COLUMNS if name in gt.columns]
+        gt["label"] = gt[columns].idxmax(axis=1)
+        df = df.merge(gt[["lesion_id", "label"]], on="lesion_id", how="left", validate="one_to_one")
+    if df.empty:
+        raise ValueError("No existing dermoscopic image files were found.")
+    return df.reset_index(drop=True)
+
+
+def build_model(checkpoint, device):
+    saved = checkpoint["args"]
+    spec = checkpoint["metadata_spec"]
+    input_dim = 2 + len(spec["sex_values"]) + len(spec["site_values"]) + len(spec.get("monet_columns", []))
+    model = DermoscopicMetadataClassifier(
+        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
+
+
+@torch.no_grad()
+def predict(model, loader, device, tta):
+    output = []
+    for batch in tqdm(loader, leave=False):
+        image = batch["image"].to(device); metadata = batch["metadata"].to(device)
+        views = [image]
+        if tta:
+            views.extend([torch.flip(image, (-1,)), torch.flip(image, (-2,)), torch.flip(image, (-2, -1))])
+        probs = sum(torch.softmax(model(view, metadata), 1) for view in views) / len(views)
+        output.append(probs.cpu().numpy())
+    return np.concatenate(output)
+
+
+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"]
+    for checkpoint in checkpoints[1:]:
+        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)
+    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 = 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:
+                raise ValueError(f"Calibration class mismatch: {calibration_path}")
+            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)
+    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)}
+        y_true = df["label"].map(mapping).to_numpy()
+        metrics, per_class, cm = compute_metrics(y_true, y_prob, class_names)
+        args.output.with_suffix(".metrics.json").write_text(json.dumps(json_safe(metrics), indent=2), encoding="utf-8")
+        per_class.to_csv(args.output.with_suffix(".per_class_metrics.csv"), index=False)
+        pd.DataFrame(cm, index=class_names, columns=class_names).to_csv(args.output.with_suffix(".confusion_matrix.csv"))
+    print(f"Saved {len(df)} dermoscopic predictions to {args.output}")
+
+
+def main():
+    run(parse_args())
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,108 @@
+"""Single-image classifier and optional metadata fusion."""
+
+from __future__ import annotations
+
+import timm
+import torch
+from torch import nn
+
+METADATA_MODES = ("none", "concat", "gated_concat", "gated_only")
+
+
+def build_feature_encoder(backbone: str, backend: str, pretrained: bool):
+    if backend == "timm":
+        encoder = timm.create_model(backbone, pretrained=pretrained, num_classes=0, global_pool="avg")
+        return encoder, int(encoder.num_features)
+    if backend != "torchvision":
+        raise ValueError(f"Unsupported backbone backend: {backend}")
+    from torchvision import models
+    builders = {
+        "efficientnet_b1": (models.efficientnet_b1, models.EfficientNet_B1_Weights),
+        "efficientnet_b2": (models.efficientnet_b2, models.EfficientNet_B2_Weights),
+        "resnet50": (models.resnet50, models.ResNet50_Weights),
+        "convnext_base": (models.convnext_base, models.ConvNeXt_Base_Weights),
+    }
+    if backbone not in builders:
+        raise ValueError(f"torchvision backend does not support backbone={backbone!r}")
+    builder, weights_enum = builders[backbone]
+    encoder = builder(weights=weights_enum.DEFAULT if pretrained else None)
+    if backbone.startswith("efficientnet") or backbone.startswith("convnext"):
+        feature_dim = int(encoder.classifier[-1].in_features)
+        encoder.classifier = nn.Identity()
+    else:
+        feature_dim = int(encoder.fc.in_features)
+        encoder.fc = nn.Identity()
+    return encoder, feature_dim
+
+
+class MetadataHead(nn.Module):
+    def __init__(self, input_dim: int, output_dim: int, dropout: float):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.LayerNorm(input_dim), nn.Linear(input_dim, max(32, output_dim * 2)), nn.GELU(),
+            nn.Dropout(dropout), nn.Linear(max(32, output_dim * 2), output_dim), nn.GELU(), nn.LayerNorm(output_dim)
+        )
+
+    def forward(self, value):
+        return self.net(value)
+
+
+class DermoscopicMetadataClassifier(nn.Module):
+    def __init__(
+        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:
+            raise ValueError(f"Unsupported metadata mode: {metadata_mode}")
+        self.metadata_mode = metadata_mode
+        self.backbone_name = backbone
+        self.backbone_backend = backbone_backend
+        self.encoder, feature_dim = build_feature_encoder(backbone, backbone_backend, imagenet_pretrained)
+        self.image_head = nn.Sequential(nn.LayerNorm(feature_dim), nn.Dropout(dropout), nn.Linear(feature_dim, branch_dim), nn.GELU(), nn.LayerNorm(branch_dim))
+        if metadata_mode == "none":
+            self.metadata_head = None
+            self.metadata_gate = None
+            classifier_input = branch_dim
+        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, 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)
+            else:
+                self.metadata_gate = None
+            classifier_input = branch_dim if metadata_mode == "gated_only" else branch_dim + metadata_dim
+        self.classifier = nn.Sequential(
+            nn.LayerNorm(classifier_input), nn.Dropout(dropout), nn.Linear(classifier_input, classifier_hidden_dim),
+            nn.GELU(), nn.Dropout(dropout), nn.Linear(classifier_hidden_dim, num_classes)
+        )
+
+    def forward(self, image: torch.Tensor, metadata: torch.Tensor | None = None) -> torch.Tensor:
+        features = self.image_head(self.encoder(image))
+        if self.metadata_mode == "none":
+            fused = features
+        else:
+            if metadata is None:
+                raise ValueError(f"metadata is required for metadata_mode={self.metadata_mode}")
+            if self.metadata_gate is not None:
+                features = features * self.metadata_gate(metadata)
+            fused = features if self.metadata_mode == "gated_only" else torch.cat([features, self.metadata_head(metadata)], dim=1)
+        return self.classifier(fused)
+
+
+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

@@ -0,0 +1,244 @@
+"""Training orchestration for single-dermoscopic-image metadata models."""
+
+from __future__ import annotations
+
+import argparse, json
+from pathlib import Path
+import numpy as np
+import pandas as pd
+import torch
+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, 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 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 ("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)
+            if training:
+                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(); 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"])
+    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,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 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()