Upload 11 files

README.md

@@ -0,0 +1,58 @@
+# MILK10k EfficientNet-B2 dermoscopic metadata
+
+Standalone single-image pipeline. It reads only rows whose `image_type` is
+`dermoscopic`; clinical images and clinical metadata are never loaded.
+`--data-dir` contains the metadata and ground-truth CSV files. Images may be
+under that directory or its parent; otherwise pass `--input-dir` explicitly.
+
+## Matched metadata ablation
+
+Run from this directory. The split manifest is created by the first run and
+reused verbatim by the second run.
+
+```bash
+python run_metadata_ablation.py \
+  --data-dir ../data_related \
+  --output-dir ../results_dermoscopic_metadata_ablation \
+  --split-manifest ../results_dermoscopic_metadata_ablation/split.json \
+  -- --amp --loss ce_dice --class-weight --freeze-epochs 5 --finetune-epochs 20
+```
+
+The comparison is written to `ablation_summary.csv`,
+`ablation_summary.json`, and `ablation_per_class.csv`. Calibration is
+intentionally disabled by the ablation runner so raw validation results are
+comparable.
+
+## One training run
+
+```bash
+python train_milk10k_effb2_dermoscopic_metadata.py \
+  --data-dir ../data_related \
+  --output-dir ../dermoscopic_with_metadata \
+  --split-manifest ../results_dermoscopic_metadata_ablation/split.json \
+  --metadata-mode concat --amp --loss ce_dice
+```
+
+`--metadata-mode` accepts `none`, `concat`, `gated_concat`, and `gated_only`.
+Use `--encoder-checkpoint` to initialize only the image encoder and
+`--resume-checkpoint RUN/last.pt` to continue an interrupted run.
+
+## Inference
+
+```bash
+python predict_milk10k_effb2_dermoscopic_metadata.py \
+  --checkpoint ../dermoscopic_with_metadata/best.pt \
+  --input-dir ../MILK10k_Test_Input \
+  --metadata-csv /path/to/MILK10k_Test_Metadata.csv \
+  --output ../test_dermoscopic_predictions.csv --tta-flips
+```
+
+If a labeled set is supplied with `--groundtruth-csv`, inference also writes
+overall, per-class, and confusion-matrix metrics. A sibling `calibration.json`
+is loaded automatically unless `--no-auto-calibration` is passed.
+
+## Outputs
+
+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`.

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,69 @@
+"""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():
+        metrics = json.loads((directory / "metrics.json").read_text(encoding="utf-8"))
+        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")
+    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,153 @@
+"""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
+from torch import nn
+
+
+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)
+
+
+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"))
+    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)),
+        "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):
+    bias = np.zeros(len(class_names), dtype=np.float32)
+    best = compute_metrics(y_true, y_prob, class_names)[0]["f1_macro"]
+    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]["f1_macro"]
+                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,203 @@
+"""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 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 create_or_load_split(df: pd.DataFrame, manifest: Path, val_size: float, seed: int) -> 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 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:
+        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))
+        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),
+                },
+                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 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()])
+        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 / counts.astype(np.float64))[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,140 @@
+"""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("--input-dir", type=Path, required=True)
+    parser.add_argument("--metadata-csv", type=Path, required=True)
+    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("--no-auto-calibration", 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"),
+    ).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"]; spec = checkpoints[0]["metadata_spec"]
+    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.")
+    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):
+        probs = predict(build_model(checkpoint, device), loader, device, args.tta_flips)
+        calibration_path = 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); output.insert(0, "lesion_id", df["lesion_id"])
+    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/model.py

@@ -0,0 +1,100 @@
+"""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",
+    ):
+        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"):
+                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.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

milk10k_effb2_dermoscopic_metadata/training.py

@@ -0,0 +1,256 @@
+"""Training CLI for the dermoscopic-only metadata classifier."""
+
+from __future__ import annotations
+
+import argparse
+import 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 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)
+
+
+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
+        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)
+        with torch.set_grad_enabled(training):
+            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)}
+
+
+@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")
+    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")
+    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}")
+
+
+def main():
+    run(parse_args())
+
+
+if __name__ == "__main__":
+    main()

predict_milk10k_effb2_dermoscopic_metadata.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python3
+from milk10k_effb2_dermoscopic_metadata.inference import main
+
+if __name__ == "__main__":
+    main()

run_metadata_ablation.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python3
+from milk10k_effb2_dermoscopic_metadata.ablation import main
+
+if __name__ == "__main__":
+    main()

train_milk10k_effb2_dermoscopic_metadata.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python3
+from milk10k_effb2_dermoscopic_metadata.training import main
+
+if __name__ == "__main__":
+    main()