Upload 14 files

Stable_diffusion_augmentation/README.md

@@ -5,6 +5,31 @@ Thư mục này có 3 script:
 - `prepare_milk10k_sd_training_set.py`: tách data MILK10k thành folder train Stable Diffusion/LoRA cho **1 class** và **1 loại ảnh**.
 - `generate_milk10k_sd.py`: dùng Stable Diffusion `img2img` để tạo ảnh augmentation cho **1 class** và **1 loại ảnh**.
 - `plot_generated_images.py`: gom ảnh trong 1 folder thành grid/contact sheet để kiểm tra nhanh.
+- `plan_and_materialize_balanced_milk10k.py`: audit phân phối real/synthetic, cap BCC, lập quota SD/QC và tùy chọn tạo dataset paired cân bằng riêng.
+
+## Audit và lập balance plan
+
+Chạy audit trên các CSV hiện có mà chưa materialize:
+
+```bash
+python Stable_diffusion_augmentation/plan_and_materialize_balanced_milk10k.py \
+  --base-data-dir data_related \
+  --report-dir data_related/augmented_info/balance_audit
+```
+
+Khi đã có ảnh synthetic và QC summary, tạo dataset riêng bằng hardlink:
+
+```bash
+python Stable_diffusion_augmentation/plan_and_materialize_balanced_milk10k.py \
+  --base-data-dir data_related \
+  --synthetic-input-dir /path/to/synthetic_prediction_input \
+  --qc-summary /path/to/effb2_qc_summary.csv \
+  --report-dir /path/to/balance_report \
+  --materialize-dir /path/to/milk10k_balanced \
+  --require-target-pred
+```
+
+Script chỉ materialize synthetic có đủ clinical + dermoscopic và pass QC. Dataset output cần train với `--synthetic-train-only` để synthetic không vào validation.
 
 ## Điểm quan trọng của MILK10k
 

Stable_diffusion_augmentation/materialize_augmented_milk10k_dataset.py

@@ -43,6 +43,12 @@ def parse_args() -> argparse.Namespace:
         action="store_true",
         help="Symlink images instead of copying. Default is copy, which is easier to move/use later.",
     )
+    parser.add_argument(
+        "--synthetic-metadata",
+        choices=["source", "neutral"],
+        default="source",
+        help="Metadata for synthetic rows. source copies source lesion metadata; neutral writes unknown/0 values.",
+    )
     parser.add_argument("--overwrite", action="store_true", help="Overwrite output CSV files and existing image links.")
     return parser.parse_args()
 
@@ -103,6 +109,28 @@ def synthetic_metadata_row(
     return row
 
 
+def source_metadata_row(
+    source_row: dict[str, str] | None,
+    columns: list[str],
+    lesion_id: str,
+    image_type: str,
+    isic_id: str,
+) -> dict[str, str]:
+    if source_row is None:
+        return synthetic_metadata_row(columns, lesion_id, image_type, isic_id)
+    row = {column: source_row.get(column, "") for column in columns}
+    row["lesion_id"] = lesion_id
+    row["image_type"] = image_type
+    row["isic_id"] = isic_id
+    if "attribution" in row:
+        row["attribution"] = "Stable Diffusion synthetic augmentation"
+    if "copyright_license" in row:
+        row["copyright_license"] = "synthetic"
+    if "image_manipulation" in row:
+        row["image_manipulation"] = "synthetic_from_source"
+    return row
+
+
 def synthetic_groundtruth_row(lesion_id: str, class_name: str, columns: list[str]) -> dict[str, str]:
     row = {column: "0.0" for column in columns}
     row["lesion_id"] = lesion_id
@@ -123,6 +151,8 @@ def materialize_synthetic_rows(
     manifest_rows: list[dict[str, str]],
     metadata_columns: list[str],
     groundtruth_columns: list[str],
+    source_metadata_by_key: dict[tuple[str, str], dict[str, str]],
+    synthetic_metadata_mode: str,
     output_input_dir: Path,
     copy_file: bool,
     overwrite: bool,
@@ -141,8 +171,31 @@ def materialize_synthetic_rows(
         link_or_copy(Path(row["clinical_generated_path"]), clinical_dst, copy_file, overwrite)
         link_or_copy(Path(row["dermoscopic_generated_path"]), dermoscopic_dst, copy_file, overwrite)
 
-        metadata_rows.append(synthetic_metadata_row(metadata_columns, lesion_id, "clinical: close-up", clinical_isic_id))
-        metadata_rows.append(synthetic_metadata_row(metadata_columns, lesion_id, "dermoscopic", dermoscopic_isic_id))
+        if synthetic_metadata_mode == "source":
+            source_lesion_id = row.get("source_lesion_id", "")
+            clinical_source_isic_id = row.get("clinical_source_isic_id", "")
+            dermoscopic_source_isic_id = row.get("dermoscopic_source_isic_id", "")
+            metadata_rows.append(
+                source_metadata_row(
+                    source_metadata_by_key.get((source_lesion_id, clinical_source_isic_id)),
+                    metadata_columns,
+                    lesion_id,
+                    "clinical: close-up",
+                    clinical_isic_id,
+                )
+            )
+            metadata_rows.append(
+                source_metadata_row(
+                    source_metadata_by_key.get((source_lesion_id, dermoscopic_source_isic_id)),
+                    metadata_columns,
+                    lesion_id,
+                    "dermoscopic",
+                    dermoscopic_isic_id,
+                )
+            )
+        else:
+            metadata_rows.append(synthetic_metadata_row(metadata_columns, lesion_id, "clinical: close-up", clinical_isic_id))
+            metadata_rows.append(synthetic_metadata_row(metadata_columns, lesion_id, "dermoscopic", dermoscopic_isic_id))
         if lesion_id not in seen_lesions:
             groundtruth_rows.append(synthetic_groundtruth_row(lesion_id, row["class_name"], groundtruth_columns))
             seen_lesions.add(lesion_id)
@@ -167,6 +220,7 @@ def main() -> None:
 
     metadata_columns = list(metadata_rows[0].keys())
     groundtruth_columns = list(groundtruth_rows[0].keys())
+    source_metadata_by_key = {(row["lesion_id"], row["isic_id"]): row for row in metadata_rows}
 
     copy_file = not args.symlink
     materialize_original_images(input_dir, output_input_dir, metadata_rows, copy_file, args.overwrite)
@@ -174,6 +228,8 @@ def main() -> None:
         manifest_rows,
         metadata_columns,
         groundtruth_columns,
+        source_metadata_by_key,
+        args.synthetic_metadata,
         output_input_dir,
         copy_file,
         args.overwrite,
@@ -191,6 +247,7 @@ def main() -> None:
     print(f"  original groundtruth rows: {len(groundtruth_rows)}")
     print(f"  synthetic groundtruth rows: {len(synthetic_groundtruth_rows)}")
     print(f"  image mode: {'symlink' if args.symlink else 'copy'}")
+    print(f"  synthetic metadata: {args.synthetic_metadata}")
     print("")
     print("Use this for training:")
     print(f"  --data-dir {output_dir}")

Stable_diffusion_augmentation/plan_and_materialize_balanced_milk10k.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+"""Audit MILK10k imbalance, plan paired SD augmentation, and optionally materialize a capped dataset."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import shutil
+from pathlib import Path
+
+os.environ.setdefault("MPLCONFIGDIR", "/tmp/matplotlib-cache")
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+try:
+    import seaborn as sns
+except ModuleNotFoundError:  # Matplotlib fallback keeps audit usable in minimal environments.
+    sns = None
+
+LABEL_COLUMNS = ["AKIEC", "BCC", "BEN_OTH", "BKL", "DF", "INF", "MAL_OTH", "MEL", "NV", "SCCKA", "VASC"]
+MODALITIES = {"clinical: close-up", "dermoscopic"}
+
+
+def parse_args(argv=None):
+    p = argparse.ArgumentParser(description="Audit and materialize a safely balanced paired MILK10k dataset.")
+    p.add_argument("--base-data-dir", type=Path, required=True)
+    p.add_argument("--base-input-dir", type=Path, default=None)
+    p.add_argument("--augmented-groundtruth", type=Path, default=None)
+    p.add_argument("--augmented-metadata", type=Path, default=None)
+    p.add_argument("--synthetic-input-dir", type=Path, default=None)
+    p.add_argument("--qc-summary", type=Path, default=None)
+    p.add_argument("--report-dir", type=Path, required=True)
+    p.add_argument("--materialize-dir", type=Path, default=None)
+    p.add_argument("--bcc-cap-ratio", type=float, default=1.5)
+    p.add_argument("--tail-floor", type=int, default=150)
+    p.add_argument("--max-synthetic-real-ratio", type=float, default=2.0)
+    p.add_argument("--max-synthetic-per-source", type=int, default=3)
+    p.add_argument("--min-target-prob", type=float, default=0.4)
+    p.add_argument("--require-target-pred", action="store_true")
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument("--num-variants", type=int, default=1)
+    p.add_argument("--link-mode", choices=["hardlink", "copy", "symlink"], default="hardlink")
+    p.add_argument("--overwrite", action="store_true")
+    return p.parse_args(argv)
+
+
+def resolve_paths(args):
+    base = args.base_data_dir.expanduser().resolve()
+    gt = base / "MILK10k_Training_GroundTruth.csv"
+    meta = base / "MILK10k_Training_Metadata.csv"
+    input_dir = (args.base_input_dir or base / "MILK10k_Training_Input").expanduser().resolve()
+    if not input_dir.exists() and args.base_input_dir is None:
+        input_dir = (base.parent / "MILK10k_Training_Input").resolve()
+    info = base / "augmented_info"
+    aug_gt = args.augmented_groundtruth or info / "MILK10k_Training_GroundTruth(2).csv"
+    aug_meta = args.augmented_metadata or info / "MILK10k_Training_Metadata(3).csv"
+    required = [gt, meta, input_dir, aug_gt, aug_meta]
+    missing = [str(path) for path in required if not path.exists()]
+    if missing: raise FileNotFoundError("Missing inputs: " + ", ".join(missing))
+    return gt, meta, input_dir, aug_gt.expanduser().resolve(), aug_meta.expanduser().resolve()
+
+
+def attach_labels(gt):
+    missing = set(LABEL_COLUMNS) - set(gt.columns)
+    if missing: raise ValueError(f"Ground truth missing labels: {sorted(missing)}")
+    result = gt.copy(); result["label"] = result[LABEL_COLUMNS].idxmax(axis=1)
+    if result.lesion_id.duplicated().any(): raise ValueError("Duplicate lesion_id in ground truth.")
+    return result
+
+
+def source_id(lesion_id): return str(lesion_id).split("__sdpair_", 1)[0]
+
+
+def load_inventory(args):
+    gt_path, meta_path, input_dir, aug_gt_path, aug_meta_path = resolve_paths(args)
+    base_gt_raw = pd.read_csv(gt_path); base_meta = pd.read_csv(meta_path); aug_gt_raw = pd.read_csv(aug_gt_path); aug_meta = pd.read_csv(aug_meta_path)
+    base_gt = attach_labels(base_gt_raw); aug_gt = attach_labels(aug_gt_raw)
+    base_ids = set(base_gt.lesion_id.astype(str)); synth_gt = aug_gt[~aug_gt.lesion_id.astype(str).isin(base_ids)].copy()
+    synth_meta = aug_meta[aug_meta.lesion_id.astype(str).isin(set(synth_gt.lesion_id.astype(str)))].copy()
+    if set(base_gt.lesion_id.astype(str)) - set(aug_gt.lesion_id.astype(str)): raise ValueError("Augmented ground truth omits base lesions.")
+    if synth_gt.lesion_id.duplicated().any(): raise ValueError("Duplicate synthetic lesion IDs.")
+    synth_gt["source_lesion_id"] = synth_gt.lesion_id.map(source_id)
+    modality_counts = synth_meta.groupby("lesion_id").image_type.agg(lambda values: set(map(str, values)))
+    synth_gt["pair_metadata_complete"] = synth_gt.lesion_id.map(lambda x: modality_counts.get(x, set()) == MODALITIES)
+    return base_gt_raw, base_gt, base_meta, synth_gt, synth_meta, input_dir
+
+
+def add_file_and_qc_status(args, synth, synth_meta):
+    result = synth.copy(); qc = None
+    if args.qc_summary:
+        qc = pd.read_csv(args.qc_summary.expanduser().resolve()).drop_duplicates("synthetic_lesion_id").set_index("synthetic_lesion_id")
+    if args.synthetic_input_dir:
+        image_root = args.synthetic_input_dir.expanduser().resolve()
+        paths = synth_meta.assign(path=synth_meta.apply(lambda row: image_root / str(row.lesion_id) / f"{row.isic_id}.jpg", axis=1))
+        file_counts = paths.groupby("lesion_id").path.agg(lambda values: sum(Path(x).exists() for x in values))
+        result["existing_image_files"] = result.lesion_id.map(lambda x: int(file_counts.get(x, 0)))
+        result["pair_files_complete"] = result.lesion_id.map(lambda x: file_counts.get(x, 0) == 2)
+    else:
+        result["existing_image_files"] = 0
+        result["pair_files_complete"] = False
+    result["qc_available"] = result.lesion_id.isin(set(qc.index)) if qc is not None else False
+    result["target_probability"] = result.lesion_id.map(qc.target_class_probability) if qc is not None and "target_class_probability" in qc else np.nan
+    result["is_target_predicted"] = result.lesion_id.map(qc.is_target_predicted).astype(str).eq("True") if qc is not None and "is_target_predicted" in qc else False
+    result["qc_pass"] = result.qc_available & (pd.to_numeric(result.target_probability, errors="coerce").fillna(0) >= args.min_target_prob)
+    if args.require_target_pred: result["qc_pass"] &= result.is_target_predicted
+    result["usable"] = result.pair_metadata_complete & result.pair_files_complete & result.qc_pass
+    return result
+
+
+def capped_synthetic(synth, real_counts, args, usable_only):
+    candidates = synth[synth.usable].copy() if usable_only else synth.copy()
+    candidates = candidates.sort_values(["label", "is_target_predicted", "target_probability", "lesion_id"], ascending=[True, False, False, True])
+    candidates["source_rank"] = candidates.groupby(["label", "source_lesion_id"]).cumcount() + 1
+    candidates = candidates[candidates.source_rank <= args.max_synthetic_per_source]
+    selected = []
+    for label, group in candidates.groupby("label", sort=True):
+        cap = int(math.floor(real_counts.get(label, 0) * args.max_synthetic_real_ratio))
+        selected.append(group.head(cap))
+    return pd.concat(selected, ignore_index=True) if selected else candidates.iloc[:0]
+
+
+def plan_counts(base, synth, inventory_selected, usable_selected, args):
+    real = base.label.value_counts().reindex(LABEL_COLUMNS, fill_value=0).astype(int)
+    raw = synth.label.value_counts().reindex(LABEL_COLUMNS, fill_value=0).astype(int)
+    inventory = inventory_selected.label.value_counts().reindex(LABEL_COLUMNS, fill_value=0).astype(int)
+    usable = usable_selected.label.value_counts().reindex(LABEL_COLUMNS, fill_value=0).astype(int)
+    second = int(real.drop("BCC").max()); bcc_cap = min(int(real.BCC), int(math.floor(second * args.bcc_cap_ratio)))
+    rows = []
+    for label in LABEL_COLUMNS:
+        target = int(real[label])
+        if label in {"BEN_OTH", "DF", "INF", "MAL_OTH", "VASC"}:
+            target = min(args.tail_floor, int(math.floor(real[label] * (1 + args.max_synthetic_real_ratio))))
+        kept_real = bcc_cap if label == "BCC" else int(real[label])
+        rows.append({"class": label, "real_count": int(real[label]), "raw_synthetic_inventory": int(raw[label]),
+                     "capped_inventory": int(inventory[label]), "verified_usable": int(usable[label]), "target_total": target,
+                     "kept_real": kept_real, "final_inventory_total": kept_real + int(inventory[label]),
+                     "final_verified_total": kept_real + int(usable[label]),
+                     "additional_needed_inventory": max(0, target - int(real[label]) - int(inventory[label])),
+                     "additional_needed_verified": max(0, target - int(real[label]) - int(usable[label]))})
+    return pd.DataFrame(rows), bcc_cap
+
+
+def bcc_strata(base_meta, base, cap, seed):
+    bcc = base[base.label.eq("BCC")][["lesion_id"]].merge(base_meta.drop_duplicates("lesion_id"), on="lesion_id", how="left")
+    age = pd.to_numeric(bcc.age_approx, errors="coerce"); bcc["age_bin"] = pd.cut(age, [-np.inf,29,49,69,np.inf], labels=["<30","30-49","50-69","70+"]).astype(str)
+    for column in ("sex", "site", "skin_tone_class", "age_bin"): bcc[column] = bcc[column].fillna("unknown").astype(str)
+    bcc["stratum"] = bcc[["sex","site","skin_tone_class","age_bin"]].agg("|".join, axis=1)
+    counts = bcc.stratum.value_counts().sort_index(); exact = counts / len(bcc) * cap; quota = np.floor(exact).astype(int)
+    for key in (exact-quota).sort_values(ascending=False).index:
+        if quota.sum() >= cap: break
+        if quota[key] < counts[key]: quota[key] += 1
+    chosen=[]; rng=np.random.default_rng(seed)
+    for key in counts.index:
+        ids=bcc.loc[bcc.stratum.eq(key),"lesion_id"].to_numpy();rng.shuffle(ids);chosen.extend(ids[:quota[key]])
+    if len(chosen)<cap:
+        remaining=np.array(sorted(set(bcc.lesion_id)-set(chosen)));rng.shuffle(remaining);chosen.extend(remaining[:cap-len(chosen)])
+    return set(map(str, chosen[:cap])), bcc
+
+
+def drift_table(bcc, selected_ids):
+    rows=[]
+    for column in ("sex","site","skin_tone_class","age_bin"):
+        full=bcc[column].value_counts(normalize=True); kept=bcc[bcc.lesion_id.astype(str).isin(selected_ids)][column].value_counts(normalize=True)
+        for value in sorted(set(full.index)|set(kept.index)): rows.append({"field":column,"value":value,"full_ratio":float(full.get(value,0)),"kept_ratio":float(kept.get(value,0)),"absolute_drift":abs(float(full.get(value,0)-kept.get(value,0)))})
+    return pd.DataFrame(rows)
+
+
+def selection_manifest(synth, inventory_ids, usable_ids):
+    result=synth.copy();result["selected_inventory"]=result.lesion_id.isin(inventory_ids);result["selected_usable"]=result.lesion_id.isin(usable_ids)
+    def reason(row):
+        if not row.pair_metadata_complete:return "incomplete_metadata_pair"
+        if not row.pair_files_complete:return "missing_image_pair"
+        if not row.qc_available:return "qc_missing"
+        if not row.qc_pass:return "qc_failed"
+        if not row.selected_usable:return "class_or_source_cap"
+        return "selected"
+    result["selection_reason"]=result.apply(reason,axis=1)
+    return result
+
+
+def source_diversity(synth, selected):
+    rows=[]
+    for label in LABEL_COLUMNS:
+        group=synth[synth.label.eq(label)]; kept=selected[selected.label.eq(label)]
+        rows.append({"class":label,"inventory":len(group),"inventory_sources":group.source_lesion_id.nunique(),
+                     "selected":len(kept),"selected_sources":kept.source_lesion_id.nunique(),
+                     "max_selected_per_source":int(kept.groupby("source_lesion_id").size().max()) if len(kept) else 0})
+    return pd.DataFrame(rows)
+
+
+def plot_reports(report_dir, distribution, sources):
+    if sns is not None:sns.set_theme(style="whitegrid")
+    def grouped(frame,x,y,hue,path,log=False):
+        plt.figure(figsize=(14,6))
+        if sns is not None:sns.barplot(data=frame,x=x,y=y,hue=hue)
+        else:
+            pivot=frame.pivot(index=x,columns=hue,values=y);pivot.plot(kind="bar",ax=plt.gca())
+        if log:plt.yscale("log")
+        plt.xticks(rotation=35);plt.tight_layout();plt.savefig(path,dpi=170);plt.close()
+    long=distribution.melt(id_vars="class",value_vars=["real_count","raw_synthetic_inventory","capped_inventory","verified_usable"],var_name="series",value_name="count")
+    grouped(long,"class","count","series",report_dir/"class_distribution.png")
+    final=distribution.melt(id_vars="class",value_vars=["real_count","final_inventory_total","final_verified_total","target_total"],var_name="series",value_name="count")
+    grouped(final,"class","count","series",report_dir/"balance_before_after.png",True)
+    ratio=distribution.assign(synthetic_real_ratio=lambda d:d.capped_inventory/d.real_count.clip(lower=1))
+    plt.figure(figsize=(12,5));
+    if sns is not None:sns.barplot(data=ratio,x="class",y="synthetic_real_ratio")
+    else:plt.bar(ratio["class"],ratio.synthetic_real_ratio)
+    plt.axhline(2,color="red",linestyle="--");plt.xticks(rotation=35);plt.tight_layout();plt.savefig(report_dir/"synthetic_real_ratio.png",dpi=170);plt.close()
+    plt.figure(figsize=(12,5));
+    if sns is not None:sns.barplot(data=sources,x="class",y="selected_sources")
+    else:plt.bar(sources["class"],sources.selected_sources)
+    plt.xticks(rotation=35);plt.tight_layout();plt.savefig(report_dir/"source_diversity.png",dpi=170);plt.close()
+
+
+def transfer(src, dst, mode, overwrite):
+    if not src.exists(): raise FileNotFoundError(src)
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    if dst.exists() or dst.is_symlink():
+        if not overwrite:return
+        dst.unlink()
+    if mode=="copy":shutil.copy2(src,dst)
+    elif mode=="symlink":dst.symlink_to(src.resolve())
+    else:
+        try:os.link(src,dst)
+        except OSError:shutil.copy2(src,dst)
+
+
+def materialize_variant(destination, base_gt_raw, base_meta, selected_base_ids, synth_gt, synth_meta, selected_synth_ids, base_input, synth_input, args):
+    if synth_input is None: raise ValueError("--synthetic-input-dir is required for materialization.")
+    if destination.exists() and not args.overwrite and any(destination.iterdir()):raise FileExistsError(f"Output is not empty: {destination}")
+    destination.mkdir(parents=True,exist_ok=True);output_images=destination/"MILK10k_Training_Input"
+    kept_gt=base_gt_raw[base_gt_raw.lesion_id.astype(str).isin(selected_base_ids)].copy()
+    kept_meta=base_meta[base_meta.lesion_id.astype(str).isin(selected_base_ids)].copy()
+    add_gt=synth_gt[synth_gt.lesion_id.astype(str).isin(selected_synth_ids)][["lesion_id",*LABEL_COLUMNS]].copy()
+    add_meta=synth_meta[synth_meta.lesion_id.astype(str).isin(selected_synth_ids)].copy()
+    counts=add_meta.groupby("lesion_id").image_type.agg(lambda x:set(map(str,x)))
+    bad=[x for x in selected_synth_ids if counts.get(x,set())!=MODALITIES]
+    if bad:raise ValueError(f"Incomplete synthetic pairs: {bad[:5]}")
+    combined_meta=pd.concat([kept_meta.assign(source_root=str(base_input)),add_meta.assign(source_root=str(synth_input))])
+    for _,row in combined_meta.iterrows():
+        src=Path(row.source_root)/str(row.lesion_id)/f"{row.isic_id}.jpg";dst=output_images/str(row.lesion_id)/f"{row.isic_id}.jpg";transfer(src,dst,args.link_mode,args.overwrite)
+    pd.concat([kept_gt,add_gt],ignore_index=True).to_csv(destination/"MILK10k_Training_GroundTruth.csv",index=False)
+    pd.concat([kept_meta,add_meta],ignore_index=True).to_csv(destination/"MILK10k_Training_Metadata.csv",index=False)
+
+
+def command_script(args, plan, report_dir):
+    needed_rows=plan[(plan.additional_needed_verified>0)&~plan["class"].eq("MAL_OTH")]
+    classes=" ".join(needed_rows["class"].astype(str));per_source=args.max_synthetic_per_source
+    max_sources=max([math.ceil(int(value)/per_source) for value in needed_rows.additional_needed_verified] or [1])
+    base_data=args.base_data_dir.expanduser().resolve();base_input=(args.base_input_dir.expanduser().resolve() if args.base_input_dir else base_data/"MILK10k_Training_Input")
+    if not base_input.exists():base_input=base_data.parent/"MILK10k_Training_Input"
+    header=["#!/usr/bin/env bash","set -euo pipefail","","# Generated commands. Review paths before running.",
+            f'BASE_DATA="{base_data}"',f'BASE_INPUT="{base_input}"',f'REPORT_DIR="{report_dir}"','CHECKPOINT_DIR="/path/to/convnext_5fold_run"',
+            'GEN_DIR="$REPORT_DIR/generated_balance_pairs"','CANDIDATE_DIR="$REPORT_DIR/candidate_augmented"','FINAL_DIR="/path/to/milk10k_balanced"',""]
+    generate=[]
+    if classes:
+        generate += [f"# Planned classes: {classes}; planner applies exact caps after QC.",
+                     f"python Stable_diffusion_augmentation/generate_milk10k_sd_pairs.py --data-dir \"$BASE_DATA\" --input-dir \"$BASE_INPUT\" --output-dir \"$GEN_DIR\" --class-names {classes} --num-per-lesion {per_source} --max-source-lesions {max_sources} --shuffle --skip-existing",""]
+    qc_materialize=["# QC outputs: $GEN_DIR/effb2_qc_predictions.csv and effb2_qc_summary.csv.",
+              "python Stable_diffusion_augmentation/run_effb2_qc.py --checkpoint-dir \"$CHECKPOINT_DIR\" --output-dir \"$GEN_DIR\"", "",
+              "python Stable_diffusion_augmentation/filter_paired_augmentation_by_qc.py --manifest \"$GEN_DIR/paired_augmentation_manifest.csv\" --qc-summary \"$GEN_DIR/effb2_qc_summary.csv\" --output \"$GEN_DIR/filtered_manifest.csv\" --min-target-prob 0.4 --require-target-pred", "",
+              "# Build a temporary complete MILK10k dataset from QC-passed pairs.",
+              "python Stable_diffusion_augmentation/materialize_augmented_milk10k_dataset.py --input-dir \"$BASE_INPUT\" --metadata-csv \"$BASE_DATA/MILK10k_Training_Metadata.csv\" --groundtruth-csv \"$BASE_DATA/MILK10k_Training_GroundTruth.csv\" --augmentation-manifest \"$GEN_DIR/filtered_manifest.csv\" --output-dir \"$CANDIDATE_DIR\" --symlink --synthetic-metadata neutral --overwrite", "",
+              "# Apply BCC stratified cap and final source/class caps into a separate dataset.",
+              "python Stable_diffusion_augmentation/plan_and_materialize_balanced_milk10k.py --base-data-dir \"$BASE_DATA\" --augmented-groundtruth \"$CANDIDATE_DIR/MILK10k_Training_GroundTruth.csv\" --augmented-metadata \"$CANDIDATE_DIR/MILK10k_Training_Metadata.csv\" --synthetic-input-dir \"$CANDIDATE_DIR/MILK10k_Training_Input\" --qc-summary \"$GEN_DIR/effb2_qc_summary.csv\" --report-dir \"$REPORT_DIR/final_audit\" --materialize-dir \"$FINAL_DIR\" --require-target-pred --overwrite", "",
+              "# Train safely: synthetic IDs stay train-only.",
+              "# python milk10k_effb2_dermoscopic_metadata/train_milk10k_effb2_dermoscopic_metadata.py --data-dir \"$FINAL_DIR\" --output-dir /path/to/run --split-manifest /path/to/run/split_v2.json --synthetic-train-only --metadata-mode none --loss ldam", ""]
+    scripts={"01_generate_pairs.sh":header+generate,"02_qc_and_materialize.sh":header+qc_materialize,
+             "run_balance_pipeline.sh":header+generate+qc_materialize}
+    for name,lines in scripts.items():
+        path=report_dir/name;path.write_text("\n".join(lines),encoding="utf-8");path.chmod(0o755)
+
+
+def report_markdown(args, plan, sources, manifest, bcc_cap, usable_count, missing_pairs, missing_image_files):
+    warnings=[]
+    if args.qc_summary is None:warnings.append("QC summary was not provided; no synthetic row is considered verified usable.")
+    if args.synthetic_input_dir is None:warnings.append("Synthetic image root was not provided; materialization is disabled.")
+    if missing_pairs:warnings.append(f"Synthetic images missing: {missing_image_files} files across {missing_pairs} incomplete inventory pairs.")
+    warnings.append("MAL_OTH should use external/manual-reviewed data; do not scale SD from only a few source lesions.")
+    lines=["# MILK10k Balance Report","",f"- BCC static cap: {bcc_cap}",f"- verified usable synthetic lesions: {usable_count}",f"- source cap: {args.max_synthetic_per_source}",f"- synthetic/real cap: {args.max_synthetic_real_ratio}x","","## Warnings",""]+[f"- {x}" for x in warnings]
+    lines += ["","## Augmentation plan","","```",plan.to_string(index=False),"```","","## Source diversity","","```",sources.to_string(index=False),"```","","## Selection reasons","",manifest.selection_reason.value_counts().to_string(),""]
+    return "\n".join(lines)
+
+
+def run(args):
+    if args.num_variants<1 or args.max_synthetic_per_source<1:raise ValueError("num variants and source cap must be positive.")
+    report_dir=args.report_dir.expanduser().resolve();report_dir.mkdir(parents=True,exist_ok=True)
+    base_gt_raw,base,base_meta,synth_gt,synth_meta,base_input=load_inventory(args)
+    synth=add_file_and_qc_status(args,synth_gt,synth_meta);real_counts=base.label.value_counts().to_dict()
+    inventory_selected=capped_synthetic(synth,real_counts,args,False);usable_selected=capped_synthetic(synth,real_counts,args,True)
+    plan,bcc_cap=plan_counts(base,synth,inventory_selected,usable_selected,args)
+    manifest=selection_manifest(synth,set(inventory_selected.lesion_id),set(usable_selected.lesion_id));sources=source_diversity(synth,inventory_selected)
+    variants=[];drifts=[]
+    materialize_error = None
+    if args.materialize_dir and len(inventory_selected) and not len(usable_selected):
+        materialize_error = ValueError(
+            "Materialization refused: synthetic inventory exists but no pair passed image/QC validation. "
+            "Check --synthetic-input-dir and --qc-summary; audit reports are still written."
+        )
+    for index in range(args.num_variants):
+        ids,bcc=bcc_strata(base_meta,base,bcc_cap,args.seed+index);selected_base=set(base.loc[~base.label.eq("BCC"),"lesion_id"].astype(str))|ids
+        variants.append(selected_base);drift=drift_table(bcc,ids);drift["variant"]=index;drifts.append(drift)
+        base[["lesion_id","label"]].assign(selected=lambda frame:frame.lesion_id.astype(str).isin(selected_base),variant=index).to_csv(report_dir/f"selected_base_manifest_variant_{index:02d}.csv",index=False)
+        if args.materialize_dir and materialize_error is None:
+            root=args.materialize_dir.expanduser().resolve();destination=root if args.num_variants==1 else root/f"variant_{index:02d}"
+            materialize_variant(destination,base_gt_raw,base_meta,selected_base,synth_gt,synth_meta,set(usable_selected.lesion_id),base_input,args.synthetic_input_dir.expanduser().resolve() if args.synthetic_input_dir else None,args)
+    plan.to_csv(report_dir/"augmentation_plan.csv",index=False);sources.to_csv(report_dir/"source_diversity.csv",index=False);manifest.to_csv(report_dir/"selected_synthetic_manifest.csv",index=False)
+    pd.concat(drifts,ignore_index=True).to_csv(report_dir/"bcc_distribution_drift.csv",index=False)
+    distribution=plan.copy();distribution.to_csv(report_dir/"class_distribution.csv",index=False);plot_reports(report_dir,distribution,sources)
+    missing_pairs=int((~synth.pair_files_complete).sum());missing_image_files=int((2-synth.existing_image_files.clip(upper=2)).sum())
+    payload={"policy":vars(args),"bcc_cap":bcc_cap,"inventory_lesions":len(synth),"usable_synthetic_lesions":len(usable_selected),"missing_image_pairs":missing_pairs,"missing_image_files":missing_image_files,"plan":plan.to_dict("records")}
+    payload["policy"]={k:str(v) if isinstance(v,Path) else v for k,v in payload["policy"].items()};(report_dir/"balance_plan.json").write_text(json.dumps(payload,indent=2),encoding="utf-8")
+    (report_dir/"balance_report.md").write_text(report_markdown(args,plan,sources,manifest,bcc_cap,len(usable_selected),missing_pairs,missing_image_files),encoding="utf-8")
+    command_script(args,plan,report_dir)
+    print(f"Base lesions: {len(base)}; synthetic inventory: {len(synth)}; verified usable: {len(usable_selected)}")
+    print(f"BCC cap: {bcc_cap}; reports: {report_dir}")
+    if materialize_error is not None:raise materialize_error
+    if args.materialize_dir:print(f"Materialized dataset: {args.materialize_dir.expanduser().resolve()}")
+    return {"plan":plan,"manifest":manifest,"bcc_cap":bcc_cap,"usable":usable_selected}
+
+
+def main():run(parse_args())
+if __name__=="__main__":main()

Stable_diffusion_augmentation/requirements.txt

@@ -10,3 +10,5 @@ pandas
 numpy
 scikit-learn
 timm
+matplotlib
+seaborn

Stable_diffusion_augmentation/run_effb2_qc.py

@@ -13,7 +13,13 @@ from pathlib import Path
 
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description="Run EffB2 QC prediction and print confidence summary.")
-    parser.add_argument("--checkpoint", type=Path, required=True, help="Path to EffB2 best.pt checkpoint.")
+    checkpoint_group = parser.add_mutually_exclusive_group(required=True)
+    checkpoint_group.add_argument("--checkpoint", type=Path, help="Path to one classifier best.pt checkpoint.")
+    checkpoint_group.add_argument(
+        "--checkpoint-dir",
+        type=Path,
+        help="Run directory containing fold_*/best.pt; all folds are ensembled for QC.",
+    )
     parser.add_argument("--output-dir", type=Path, default=Path("Stable_diffusion_augmentation/out_minority_pairs"))
     parser.add_argument("--batch-size", type=int, default=16)
     parser.add_argument("--image-size", type=int, default=384)
@@ -129,7 +135,8 @@ def print_confidence_summary(summary_path: Path, print_misses: int) -> None:
 def main() -> None:
     args = parse_args()
     output_dir = args.output_dir.expanduser().resolve()
-    checkpoint = args.checkpoint.expanduser().resolve()
+    checkpoint = args.checkpoint.expanduser().resolve() if args.checkpoint else None
+    checkpoint_dir = args.checkpoint_dir.expanduser().resolve() if args.checkpoint_dir else None
     manifest = output_dir / "paired_augmentation_manifest.csv"
     metadata_csv = output_dir / "metadata_for_prediction.csv"
     groundtruth_csv = output_dir / "groundtruth_for_prediction.csv"
@@ -144,16 +151,19 @@ def main() -> None:
         "Summary script",
     )
 
-    for path in (checkpoint, manifest, metadata_csv, groundtruth_csv, input_dir):
+    for path in (checkpoint or checkpoint_dir, manifest, metadata_csv, groundtruth_csv, input_dir):
         if not path.exists():
             raise FileNotFoundError(f"Required QC input not found: {path}")
 
-    run_command(
-        [
+    predict_command = [
             args.python,
             str(predict_script),
-            "--checkpoint",
-            str(checkpoint),
+    ]
+    if checkpoint is not None:
+        predict_command.extend(["--checkpoint", str(checkpoint)])
+    else:
+        predict_command.extend(["--checkpoint-dir", str(checkpoint_dir)])
+    predict_command.extend([
             "--input-dir",
             str(input_dir),
             "--metadata-csv",
@@ -169,8 +179,8 @@ def main() -> None:
             str(args.image_size),
             "--num-workers",
             str(args.num_workers),
-        ]
-    )
+        ])
+    run_command(predict_command)
     run_command(
         [
             args.python,

Stable_diffusion_augmentation/tests/test_balance_planner.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+import sys,tempfile,unittest
+from pathlib import Path
+import numpy as np,pandas as pd
+from PIL import Image
+
+sys.path.insert(0,str(Path(__file__).resolve().parents[1]))
+from plan_and_materialize_balanced_milk10k import LABEL_COLUMNS,parse_args,run
+
+
+def gt_row(lesion,label):
+    return {"lesion_id":lesion,**{name:float(name==label) for name in LABEL_COLUMNS}}
+
+
+def image(path,value):
+    path.parent.mkdir(parents=True,exist_ok=True);Image.fromarray(np.full((8,8,3),value,dtype=np.uint8)).save(path)
+
+
+def fixture(root,missing_synthetic=False):
+    base=root/"base";images=base/"MILK10k_Training_Input";base.mkdir()
+    labels=["BCC"]*10+["NV"]*4+["BEN_OTH"]*2
+    gt=[];meta=[]
+    for i,label in enumerate(labels):
+        lesion=f"L{i}";gt.append(gt_row(lesion,label))
+        for modality,suffix in (("clinical: close-up","c"),("dermoscopic","d")):
+            isic=f"{lesion}_{suffix}";meta.append({"lesion_id":lesion,"image_type":modality,"isic_id":isic,"age_approx":40+i,"sex":"x","skin_tone_class":2,"site":"arm"});image(images/lesion/f"{isic}.jpg",80+i)
+    pd.DataFrame(gt).to_csv(base/"MILK10k_Training_GroundTruth.csv",index=False);pd.DataFrame(meta).to_csv(base/"MILK10k_Training_Metadata.csv",index=False)
+    synth_root=root/"synthetic";aug_gt=list(gt);aug_meta=list(meta);qc=[]
+    for i in range(4):
+        lesion=f"L{10+i%2}__sdpair_{i:03d}";aug_gt.append(gt_row(lesion,"BEN_OTH"))
+        for modality,suffix in (("clinical: close-up","clinical"),("dermoscopic","dermoscopic")):
+            isic=f"{lesion}__{suffix}";aug_meta.append({"lesion_id":lesion,"image_type":modality,"isic_id":isic,"age_approx":"","sex":"unknown","skin_tone_class":"","site":"unknown"})
+            if not missing_synthetic:image(synth_root/lesion/f"{isic}.jpg",120+i)
+        qc.append({"synthetic_lesion_id":lesion,"target_class_probability":.9-i*.1,"is_target_predicted":"True"})
+    info=base/"augmented_info";info.mkdir();pd.DataFrame(aug_gt).to_csv(info/"MILK10k_Training_GroundTruth(2).csv",index=False);pd.DataFrame(aug_meta).to_csv(info/"MILK10k_Training_Metadata(3).csv",index=False)
+    qc_path=root/"qc.csv";pd.DataFrame(qc).to_csv(qc_path,index=False)
+    return base,synth_root,qc_path
+
+
+class BalancePlannerTests(unittest.TestCase):
+    def test_caps_qc_reproducibility_and_hardlink_materialization(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root=Path(tmp);base,synth,qc=fixture(root)
+            outputs=[]
+            for index in range(2):
+                report=root/f"report{index}";materialized=root/f"out{index}"
+                args=parse_args(["--base-data-dir",str(base),"--synthetic-input-dir",str(synth),"--qc-summary",str(qc),"--report-dir",str(report),"--materialize-dir",str(materialized),"--max-synthetic-per-source","1","--seed","7"])
+                result=run(args);outputs.append(pd.read_csv(materialized/"MILK10k_Training_GroundTruth.csv"))
+                self.assertEqual(result["bcc_cap"],6);self.assertLessEqual(len(result["usable"]),2)
+                self.assertTrue((report/"class_distribution.png").exists());self.assertTrue((report/"run_balance_pipeline.sh").exists())
+                first=materialized/"MILK10k_Training_Input/L0/L0_c.jpg";self.assertEqual(first.stat().st_ino,(base/"MILK10k_Training_Input/L0/L0_c.jpg").stat().st_ino)
+            self.assertEqual(set(outputs[0].lesion_id),set(outputs[1].lesion_id))
+
+    def test_materialization_refuses_missing_synthetic_pairs(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root=Path(tmp);base,synth,qc=fixture(root,True)
+            args=parse_args(["--base-data-dir",str(base),"--synthetic-input-dir",str(synth),"--qc-summary",str(qc),"--report-dir",str(root/"report"),"--materialize-dir",str(root/"out")])
+            with self.assertRaises((ValueError,FileNotFoundError)):run(args)
+
+    def test_audit_without_images_reports_inventory_but_no_usable(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root=Path(tmp);base,_,_=fixture(root)
+            result=run(parse_args(["--base-data-dir",str(base),"--report-dir",str(root/"report")]))
+            self.assertEqual(len(result["manifest"]),4);self.assertEqual(len(result["usable"]),0)
+
+
+if __name__=="__main__":unittest.main()