Upload 35 files

milk10k_effb2_metadata/reporting.py

@@ -0,0 +1,498 @@
+"""Run reporting helpers for MILK10k training outputs."""
+
+from __future__ import annotations
+
+import json
+import math
+import platform
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+from milk10k_effb2_metadata.training_utils import json_safe
+
+
+WATCHED_CONFUSIONS = {
+    "INF": ["BEN_OTH", "NV", "BCC"],
+    "BCC": ["AKIEC", "BKL", "SCCKA"],
+    "SCCKA": ["AKIEC", "BKL"],
+    "AKIEC": ["SCCKA"],
+    "BKL": ["SCCKA"],
+}
+
+
+def collect_environment_info() -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "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,
+    }
+    try:
+        import torch
+
+        payload["torch"] = {
+            "version": torch.__version__,
+            "cuda_available": torch.cuda.is_available(),
+            "cuda_device_count": torch.cuda.device_count(),
+            "cuda_device_name": torch.cuda.get_device_name(0) if torch.cuda.is_available() else None,
+        }
+    except Exception as exc:  # pragma: no cover - defensive only.
+        payload["torch"] = {"error": repr(exc)}
+
+    payload["git"] = git_info(Path.cwd())
+    return payload
+
+
+def git_info(cwd: Path) -> dict[str, Any]:
+    def run_git(args: list[str]) -> str | None:
+        try:
+            result = subprocess.run(
+                ["git", *args],
+                cwd=cwd,
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+        except Exception:
+            return None
+        if result.returncode != 0:
+            return None
+        return result.stdout.strip()
+
+    commit = run_git(["rev-parse", "HEAD"])
+    if commit is None:
+        return {"available": False}
+    status = run_git(["status", "--short"]) or ""
+    branch = run_git(["rev-parse", "--abbrev-ref", "HEAD"])
+    return {
+        "available": True,
+        "commit": commit,
+        "branch": branch,
+        "dirty": bool(status),
+        "status_short": status.splitlines(),
+    }
+
+
+def class_distribution(df: pd.DataFrame, class_names: list[str]) -> dict[str, Any]:
+    counts = df["label"].value_counts().reindex(class_names, fill_value=0).astype(int).to_dict()
+    is_augmented = synthetic_mask(df)
+    ignore_metadata = (
+        df["ignore_metadata"].fillna(False).astype(bool).to_numpy()
+        if "ignore_metadata" in df.columns
+        else np.zeros(len(df), dtype=bool)
+    )
+    augmented_counts = (
+        df.loc[is_augmented, "label"].value_counts().reindex(class_names, fill_value=0).astype(int).to_dict()
+        if len(df)
+        else {name: 0 for name in class_names}
+    )
+    return {
+        "rows": int(len(df)),
+        "class_counts": counts,
+        "real_rows": int((~is_augmented).sum()),
+        "synthetic_rows": int(is_augmented.sum()),
+        "synthetic_class_counts": augmented_counts,
+        "ignore_metadata_rows": int(ignore_metadata.sum()),
+    }
+
+
+def synthetic_mask(df: pd.DataFrame) -> np.ndarray:
+    mask = np.zeros(len(df), dtype=bool)
+    if "is_augmented" in df.columns:
+        mask |= df["is_augmented"].fillna(False).astype(bool).to_numpy()
+    if "lesion_id" in df.columns:
+        mask |= df["lesion_id"].astype(str).str.contains("__sdpair_", regex=False).to_numpy()
+    return mask
+
+
+def build_data_summary(
+    full_df: pd.DataFrame,
+    train_df: pd.DataFrame,
+    val_df: pd.DataFrame,
+    class_names: list[str],
+) -> dict[str, Any]:
+    return {
+        "full": class_distribution(full_df, class_names),
+        "train": class_distribution(train_df, class_names),
+        "val": class_distribution(val_df, class_names),
+        "synthetic_train_only": bool(synthetic_mask(train_df).sum() and not synthetic_mask(val_df).sum()),
+    }
+
+
+def build_prediction_summary(y_prob: np.ndarray, class_names: list[str], low_confidence_threshold: float = 0.5) -> dict[str, Any]:
+    if y_prob.size == 0:
+        return {
+            "rows": 0,
+            "predicted_class_counts": {name: 0 for name in class_names},
+            "mean_probability": {name: 0.0 for name in class_names},
+        }
+    y_pred = y_prob.argmax(axis=1)
+    counts = np.bincount(y_pred, minlength=len(class_names))
+    sorted_prob = np.sort(y_prob, axis=1)
+    confidence = sorted_prob[:, -1]
+    second = sorted_prob[:, -2] if y_prob.shape[1] > 1 else np.zeros_like(confidence)
+    entropy = -np.sum(y_prob * np.log(np.clip(y_prob, 1e-12, 1.0)), axis=1)
+    return {
+        "rows": int(y_prob.shape[0]),
+        "predicted_class_counts": {name: int(counts[idx]) for idx, name in enumerate(class_names)},
+        "mean_probability": {name: float(y_prob[:, idx].mean()) for idx, name in enumerate(class_names)},
+        "median_probability": {name: float(np.median(y_prob[:, idx])) for idx, name in enumerate(class_names)},
+        "mean_confidence": float(confidence.mean()),
+        "median_confidence": float(np.median(confidence)),
+        "mean_top1_top2_gap": float((confidence - second).mean()),
+        "median_top1_top2_gap": float(np.median(confidence - second)),
+        "mean_entropy": float(entropy.mean()),
+        "median_entropy": float(np.median(entropy)),
+        "low_confidence_threshold": float(low_confidence_threshold),
+        "low_confidence_rows": int((confidence < low_confidence_threshold).sum()),
+    }
+
+
+def build_confusion_analysis(cm: np.ndarray, class_names: list[str], top_k: int = 20) -> dict[str, Any]:
+    false_negatives: dict[str, list[dict[str, Any]]] = {}
+    false_positives: dict[str, list[dict[str, Any]]] = {}
+    pairs = []
+    watched = []
+
+    for true_idx, true_name in enumerate(class_names):
+        row_total = int(cm[true_idx, :].sum())
+        entries = []
+        for pred_idx, pred_name in enumerate(class_names):
+            if pred_idx == true_idx:
+                continue
+            count = int(cm[true_idx, pred_idx])
+            if count <= 0:
+                continue
+            entry = {
+                "true": true_name,
+                "predicted": pred_name,
+                "count": count,
+                "rate_of_true": count / row_total if row_total else 0.0,
+            }
+            entries.append(entry)
+            pairs.append(entry)
+            if pred_name in WATCHED_CONFUSIONS.get(true_name, []):
+                watched.append(entry)
+        false_negatives[true_name] = sorted(entries, key=lambda item: item["count"], reverse=True)
+
+    for pred_idx, pred_name in enumerate(class_names):
+        col_total = int(cm[:, pred_idx].sum())
+        entries = []
+        for true_idx, true_name in enumerate(class_names):
+            if pred_idx == true_idx:
+                continue
+            count = int(cm[true_idx, pred_idx])
+            if count <= 0:
+                continue
+            entries.append(
+                {
+                    "predicted": pred_name,
+                    "true": true_name,
+                    "count": count,
+                    "rate_of_predicted": count / col_total if col_total else 0.0,
+                }
+            )
+        false_positives[pred_name] = sorted(entries, key=lambda item: item["count"], reverse=True)
+
+    pairs = sorted(pairs, key=lambda item: item["count"], reverse=True)
+    watched = sorted(watched, key=lambda item: item["count"], reverse=True)
+    return {
+        "false_negatives_by_true_class": false_negatives,
+        "false_positives_by_predicted_class": false_positives,
+        "top_confusion_pairs": pairs[:top_k],
+        "watched_confusion_patterns": watched,
+    }
+
+
+def build_run_warnings(
+    metrics: dict[str, Any],
+    per_class_df: pd.DataFrame,
+    cm: np.ndarray,
+    prediction_summary: dict[str, Any],
+) -> list[dict[str, Any]]:
+    del metrics
+    class_names = per_class_df["class"].tolist()
+    warnings: list[dict[str, Any]] = []
+    pred_counts = prediction_summary.get("predicted_class_counts", {})
+    total_pred = max(int(prediction_summary.get("rows", 0)), 1)
+
+    for class_name in ("INF", "BEN_OTH"):
+        if class_name in pred_counts and int(pred_counts[class_name]) == 0:
+            warnings.append(warning("tail_predicted_zero", "high", f"{class_name} has zero predicted rows.", class_name))
+
+    mal_count = int(pred_counts.get("MAL_OTH", 0))
+    if mal_count > max(2, math.ceil(total_pred * 0.01)):
+        warnings.append(warning("mal_oth_many_predictions", "medium", f"MAL_OTH predicted {mal_count} times.", "MAL_OTH"))
+
+    if "BCC" in class_names:
+        bcc_idx = class_names.index("BCC")
+        bcc_support = int(cm[bcc_idx, :].sum())
+        bcc_pred = int(cm[:, bcc_idx].sum())
+        if bcc_support and bcc_pred < max(1, int(bcc_support * 0.65)):
+            warnings.append(
+                warning("bcc_predicted_low", "high", f"BCC predicted {bcc_pred} times for {bcc_support} validation BCC rows.", "BCC")
+            )
+        drift_targets = [name for name in ("AKIEC", "BKL", "SCCKA") if name in class_names]
+        drift_count = sum(int(cm[bcc_idx, class_names.index(name)]) for name in drift_targets)
+        if bcc_support and drift_count >= max(3, int(bcc_support * 0.08)):
+            warnings.append(
+                warning("bcc_boundary_drift", "high", f"BCC -> AKIEC/BKL/SCCKA count is {drift_count}.", "BCC")
+            )
+
+    for row in per_class_df.to_dict("records"):
+        class_name = str(row["class"])
+        support = int(row.get("support", 0))
+        precision = float(row.get("precision", 0.0))
+        recall = float(row.get("recall_sensitivity", 0.0))
+        if support <= 5:
+            warnings.append(
+                warning("tiny_validation_support", "medium", f"{class_name} validation support is only {support}.", class_name)
+            )
+        if class_name in {"BEN_OTH", "DF", "INF", "MAL_OTH", "VASC"} and recall >= 0.2 and precision < 0.2:
+            warnings.append(
+                warning(
+                    "tail_precision_low",
+                    "high",
+                    f"{class_name} recall={recall:.3f} but precision={precision:.3f}.",
+                    class_name,
+                )
+            )
+
+    mean_conf = float(prediction_summary.get("mean_confidence", 0.0))
+    mean_entropy = float(prediction_summary.get("mean_entropy", 0.0))
+    if mean_conf > 0.9 and mean_entropy < 0.35:
+        warnings.append(
+            warning("high_confidence_low_entropy", "medium", f"mean_confidence={mean_conf:.3f}, mean_entropy={mean_entropy:.3f}.")
+        )
+    return warnings
+
+
+def warning(code: str, severity: str, message: str, class_name: str | None = None) -> dict[str, Any]:
+    payload = {"code": code, "severity": severity, "message": message}
+    if class_name is not None:
+        payload["class"] = class_name
+    return payload
+
+
+def save_data_summary(output_dir: Path, data_summary: dict[str, Any]) -> None:
+    with open(output_dir / "data_summary.json", "w", encoding="utf-8") as f:
+        json.dump(json_safe(data_summary), f, indent=2)
+    (output_dir / "split_summary.md").write_text(render_split_summary(data_summary), encoding="utf-8")
+
+
+def save_run_diagnostics(
+    output_dir: Path,
+    args: Any,
+    data_summary: dict[str, Any],
+    metrics: dict[str, Any],
+    per_class_df: pd.DataFrame,
+    cm: np.ndarray,
+    y_prob: np.ndarray,
+    class_names: list[str],
+    fold: int | None = None,
+) -> dict[str, Any]:
+    prediction_summary = build_prediction_summary(y_prob, class_names)
+    confusion_analysis = build_confusion_analysis(cm, class_names)
+    warnings = build_run_warnings(metrics, per_class_df, cm, prediction_summary)
+    diagnostics = {
+        "fold": fold,
+        "warnings": warnings,
+        "prediction_summary": prediction_summary,
+        "confusion_analysis": confusion_analysis,
+    }
+    with open(output_dir / "prediction_summary.json", "w", encoding="utf-8") as f:
+        json.dump(json_safe(prediction_summary), f, indent=2)
+    with open(output_dir / "confusion_analysis.json", "w", encoding="utf-8") as f:
+        json.dump(json_safe(confusion_analysis), f, indent=2)
+    with open(output_dir / "run_diagnostics.json", "w", encoding="utf-8") as f:
+        json.dump(json_safe(diagnostics), f, indent=2)
+    (output_dir / "run_report.md").write_text(
+        render_run_report(args, data_summary, metrics, per_class_df, prediction_summary, confusion_analysis, warnings, fold),
+        encoding="utf-8",
+    )
+    return diagnostics
+
+
+def save_kfold_report(fold_metrics: list[dict[str, Any]], output_dir: Path) -> None:
+    diagnostics = []
+    for fold_dir in sorted(output_dir.glob("fold_*/run_diagnostics.json")):
+        with open(fold_dir, encoding="utf-8") as f:
+            payload = json.load(f)
+        payload["path"] = str(fold_dir)
+        diagnostics.append(payload)
+    (output_dir / "kfold_report.md").write_text(render_kfold_report(fold_metrics, diagnostics), encoding="utf-8")
+
+
+def render_split_summary(data_summary: dict[str, Any]) -> str:
+    lines = ["# Split Summary", ""]
+    for split in ("full", "train", "val"):
+        summary = data_summary[split]
+        lines.extend(
+            [
+                f"## {split.title()}",
+                "",
+                f"- rows: {summary['rows']}",
+                f"- real_rows: {summary['real_rows']}",
+                f"- synthetic_rows: {summary['synthetic_rows']}",
+                f"- ignore_metadata_rows: {summary['ignore_metadata_rows']}",
+                "",
+                "| class | count | synthetic |",
+                "|---|---:|---:|",
+            ]
+        )
+        for class_name, count in summary["class_counts"].items():
+            lines.append(f"| {class_name} | {count} | {summary['synthetic_class_counts'].get(class_name, 0)} |")
+        lines.append("")
+    lines.append(f"- synthetic_train_only: {data_summary['synthetic_train_only']}")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def render_run_report(
+    args: Any,
+    data_summary: dict[str, Any],
+    metrics: dict[str, Any],
+    per_class_df: pd.DataFrame,
+    prediction_summary: dict[str, Any],
+    confusion_analysis: dict[str, Any],
+    warnings: list[dict[str, Any]],
+    fold: int | None,
+) -> str:
+    lines = ["# MILK10k Run Report", ""]
+    lines.extend(
+        [
+            "## Config Summary",
+            "",
+            f"- fold: {fold}",
+            f"- output_dir: {getattr(args, 'output_dir', None)}",
+            f"- backbone: {getattr(args, 'backbone', None)}",
+            f"- metadata_fusion: {getattr(args, 'metadata_fusion', None)}",
+            f"- image_fusion: {getattr(args, 'image_fusion', None)}",
+            f"- loss: {getattr(args, 'loss', None)}",
+            f"- class_weight: {getattr(args, 'class_weight', None)}",
+            f"- weighted_sampler: {getattr(args, 'weighted_sampler', None)}",
+            f"- augmented_data_dir: {getattr(args, 'augmented_data_dir', None)}",
+            f"- augmented_classes: {getattr(args, 'augmented_classes', None)}",
+            f"- augmented_max_per_class: {getattr(args, 'augmented_max_per_class', None)}",
+            f"- freeze_metadata_head: {getattr(args, 'freeze_metadata_head', None)}",
+            f"- zero_augmented_metadata: {getattr(args, 'zero_augmented_metadata', None)}",
+            "",
+            "## Final Metrics",
+            "",
+        ]
+    )
+    for key in ("accuracy", "balanced_accuracy", "dice_macro", "f1_macro", "roc_auc_macro_ovr", "top2_accuracy", "top3_accuracy"):
+        lines.append(f"- {key}: {metrics.get(key)}")
+    lines.extend(["", "## Data Distribution", "", render_distribution_table(data_summary["train"], "Train"), ""])
+    lines.extend([render_distribution_table(data_summary["val"], "Validation"), ""])
+    lines.extend(["## Per-Class Metrics", "", dataframe_to_markdown(per_class_df), ""])
+    weak = per_class_df.sort_values(["f1", "support"], ascending=[True, True]).head(5)
+    lines.extend(["## Weak Classes", "", dataframe_to_markdown(weak), ""])
+    lines.extend(["## Prediction Distribution", "", "| class | pred_count | mean_prob |", "|---|---:|---:|"])
+    for class_name, count in prediction_summary.get("predicted_class_counts", {}).items():
+        mean_prob = prediction_summary.get("mean_probability", {}).get(class_name, 0.0)
+        lines.append(f"| {class_name} | {count} | {mean_prob:.4f} |")
+    lines.extend(
+        [
+            "",
+            f"- mean_confidence: {prediction_summary.get('mean_confidence')}",
+            f"- median_confidence: {prediction_summary.get('median_confidence')}",
+            f"- mean_top1_top2_gap: {prediction_summary.get('mean_top1_top2_gap')}",
+            f"- mean_entropy: {prediction_summary.get('mean_entropy')}",
+            f"- low_confidence_rows: {prediction_summary.get('low_confidence_rows')}",
+            "",
+            "## Top Confusion Pairs",
+            "",
+            "| true | predicted | count | rate_of_true |",
+            "|---|---|---:|---:|",
+        ]
+    )
+    for item in confusion_analysis.get("top_confusion_pairs", [])[:12]:
+        lines.append(f"| {item['true']} | {item['predicted']} | {item['count']} | {item['rate_of_true']:.3f} |")
+    lines.extend(["", "## Watched Confusion Patterns", "", "| true | predicted | count | rate_of_true |", "|---|---|---:|---:|"])
+    for item in confusion_analysis.get("watched_confusion_patterns", [])[:12]:
+        lines.append(f"| {item['true']} | {item['predicted']} | {item['count']} | {item['rate_of_true']:.3f} |")
+    lines.extend(["", "## Warnings", ""])
+    if warnings:
+        for item in warnings:
+            lines.append(f"- [{item['severity']}] {item['code']}: {item['message']}")
+    else:
+        lines.append("- none")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def render_distribution_table(summary: dict[str, Any], title: str) -> str:
+    lines = [
+        f"### {title}",
+        "",
+        f"- rows: {summary['rows']}",
+        f"- real_rows: {summary['real_rows']}",
+        f"- synthetic_rows: {summary['synthetic_rows']}",
+        f"- ignore_metadata_rows: {summary['ignore_metadata_rows']}",
+        "",
+        "| class | count | synthetic |",
+        "|---|---:|---:|",
+    ]
+    for class_name, count in summary["class_counts"].items():
+        lines.append(f"| {class_name} | {count} | {summary['synthetic_class_counts'].get(class_name, 0)} |")
+    return "\n".join(lines)
+
+
+def render_kfold_report(fold_metrics: list[dict[str, Any]], diagnostics: list[dict[str, Any]]) -> str:
+    lines = ["# MILK10k K-Fold Report", ""]
+    if fold_metrics:
+        df = pd.DataFrame(fold_metrics)
+        metric_cols = [
+            col
+            for col in ("accuracy", "balanced_accuracy", "dice_macro", "f1_macro", "roc_auc_macro_ovr", "top3_accuracy")
+            if col in df.columns
+        ]
+        lines.extend(["## Fold Metrics", "", dataframe_to_markdown(df[["fold", *metric_cols]]), ""])
+        rows = []
+        for col in metric_cols:
+            values = pd.to_numeric(df[col], errors="coerce").dropna()
+            rows.append({"metric": col, "mean": values.mean() if len(values) else None, "std": values.std(ddof=0) if len(values) else None})
+        lines.extend(["## Aggregate", "", dataframe_to_markdown(pd.DataFrame(rows)), ""])
+    lines.extend(["## Fold Warnings", ""])
+    any_warning = False
+    for payload in diagnostics:
+        fold = payload.get("fold")
+        for item in payload.get("warnings", []):
+            any_warning = True
+            lines.append(f"- fold={fold} [{item['severity']}] {item['code']}: {item['message']}")
+    if not any_warning:
+        lines.append("- none")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def dataframe_to_markdown(df: pd.DataFrame) -> str:
+    if df.empty:
+        return "_empty_"
+    columns = [str(col) for col in df.columns]
+    lines = [
+        "| " + " | ".join(columns) + " |",
+        "| " + " | ".join("---" for _ in columns) + " |",
+    ]
+    for _, row in df.iterrows():
+        values = [format_markdown_value(row[col]) for col in df.columns]
+        lines.append("| " + " | ".join(values) + " |")
+    return "\n".join(lines)
+
+
+def format_markdown_value(value: Any) -> str:
+    if pd.isna(value):
+        return ""
+    if isinstance(value, float):
+        return f"{value:.6g}"
+    return str(value)

milk10k_effb2_metadata/runner.py

@@ -22,6 +22,7 @@ from milk10k_effb2_metadata.engine import train_phase
 from milk10k_effb2_metadata.losses import build_loss
 from milk10k_effb2_metadata.metrics import apply_class_bias, compute_metrics, optimize_class_bias, predict, save_predictions
 from milk10k_effb2_metadata.model_setup import build_model, load_resume_checkpoint
+from milk10k_effb2_metadata.reporting import build_data_summary, save_data_summary, save_kfold_report, save_run_diagnostics
 from milk10k_effb2_metadata.training_utils import json_safe, save_kfold_summary, save_run_config
 
 
@@ -125,6 +126,8 @@ def run_training_split(
     split_dir.mkdir(exist_ok=True)
     train_df.to_csv(split_dir / "train.csv", index=False)
     val_df.to_csv(split_dir / "val.csv", index=False)
+    data_summary = build_data_summary(df, train_df, val_df, class_names)
+    save_data_summary(output_dir, data_summary)
 
     metadata_spec = fit_metadata_spec(train_df)
     metadata_dim = len(metadata_vector(train_df.iloc[0], metadata_spec))
@@ -132,6 +135,7 @@ def run_training_split(
         output_dir,
         args,
         class_names,
+        label_to_idx,
         metadata_spec,
         train_df,
         val_df,
@@ -277,6 +281,17 @@ def run_training_split(
     pd.DataFrame(cm, index=class_names, columns=class_names).to_csv(output_dir / "confusion_matrix.csv")
     per_class_df.to_csv(output_dir / "per_class_metrics.csv", index=False)
     save_predictions(val_df, y_true, y_prob, class_names, output_dir)
+    save_run_diagnostics(
+        output_dir,
+        args,
+        data_summary,
+        metrics,
+        per_class_df,
+        cm,
+        y_prob,
+        class_names,
+        fold,
+    )
     print(
         f"Done: best_val_f1_macro={best_val_f1:.4f}, "
         f"val_acc={metrics['accuracy']:.4f}, balanced_acc={metrics['balanced_accuracy']:.4f}, "
@@ -356,4 +371,5 @@ def train_kfold(
         )
         fold_metrics.append({"fold": fold_idx, **metrics})
     save_kfold_summary(fold_metrics, args.output_dir)
+    save_kfold_report(fold_metrics, args.output_dir)
     return fold_metrics

milk10k_effb2_metadata/training_utils.py

@@ -17,6 +17,7 @@ def save_run_config(
     output_dir: Path,
     args: argparse.Namespace,
     class_names: list[str],
+    label_to_idx: dict[str, int],
     metadata_spec: dict[str, Any],
     train_df: pd.DataFrame,
     val_df: pd.DataFrame,
@@ -26,9 +27,13 @@ def save_run_config(
 ) -> None:
     import pandas as pd
 
+    from milk10k_effb2_metadata.reporting import collect_environment_info
+
     payload = {
         "args": json_safe(vars(args)),
+        "environment": collect_environment_info(),
         "class_names": class_names,
+        "label_to_idx": label_to_idx,
         "metadata_spec": json_safe(metadata_spec),
         "train_size": len(train_df),
         "val_size": len(val_df),
@@ -37,6 +42,14 @@ def save_run_config(
         "image_fusion": getattr(args, "image_fusion", "concat"),
         "clinical_backbone": f"{clinical_backbone_backend} {args.backbone}",
         "dermoscopic_backbone": f"{dermoscopic_backbone_backend} {args.backbone}",
+        "paths": {
+            "output_dir": str(output_dir),
+            "data_dir": str(getattr(args, "data_dir", "")),
+            "clinical_checkpoint": str(getattr(args, "clinical_checkpoint", "")),
+            "dermoscopic_checkpoint": str(getattr(args, "dermoscopic_checkpoint", "")),
+            "resume_checkpoint": str(getattr(args, "resume_checkpoint", "")),
+            "augmented_data_dir": str(getattr(args, "augmented_data_dir", "")),
+        },
     }
     with open(output_dir / "run_config.json", "w", encoding="utf-8") as f:
         json.dump(payload, f, indent=2)