Upload 21 files

Stable_diffusion_augmentation/materialize_augmented_milk10k_dataset.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""Create a MILK10k-style dataset folder with original + synthetic paired augmentations."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import shutil
+from pathlib import Path
+
+
+LABEL_COLUMNS = [
+    "AKIEC",
+    "BCC",
+    "BEN_OTH",
+    "BKL",
+    "DF",
+    "INF",
+    "MAL_OTH",
+    "MEL",
+    "NV",
+    "SCCKA",
+    "VASC",
+]
+
+NEUTRAL_METADATA = {
+    "age_approx": "",
+    "sex": "unknown",
+    "skin_tone_class": "",
+    "site": "unknown",
+}
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Materialize original + synthetic data as a MILK10k-style dataset.")
+    parser.add_argument("--input-dir", type=Path, required=True, help="Original MILK10k_Training_Input folder.")
+    parser.add_argument("--metadata-csv", type=Path, required=True, help="Original MILK10k_Training_Metadata.csv.")
+    parser.add_argument("--groundtruth-csv", type=Path, required=True, help="Original MILK10k_Training_GroundTruth.csv.")
+    parser.add_argument("--augmentation-manifest", type=Path, required=True, help="Paired augmentation manifest to add.")
+    parser.add_argument("--output-dir", type=Path, required=True, help="Output MILK10k-style dataset folder.")
+    parser.add_argument(
+        "--symlink",
+        action="store_true",
+        help="Symlink images instead of copying. Default is copy, which is easier to move/use later.",
+    )
+    parser.add_argument("--overwrite", action="store_true", help="Overwrite output CSV files and existing image links.")
+    return parser.parse_args()
+
+
+def read_rows(path: Path) -> list[dict[str, str]]:
+    with path.open(newline="") as f:
+        return list(csv.DictReader(f))
+
+
+def write_rows(path: Path, rows: list[dict[str, str]], fieldnames: list[str]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def link_or_copy(src: Path, dst: Path, copy_file: bool, overwrite: bool) -> None:
+    if not src.exists():
+        raise FileNotFoundError(f"Source image not found: {src}")
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    if dst.exists() or dst.is_symlink():
+        if not overwrite:
+            return
+        dst.unlink()
+    if copy_file:
+        shutil.copy2(src, dst)
+    else:
+        dst.symlink_to(src.resolve())
+
+
+def original_image_path(input_dir: Path, row: dict[str, str]) -> Path:
+    return input_dir / row["lesion_id"] / f"{row['isic_id']}.jpg"
+
+
+def synthetic_metadata_row(
+    columns: list[str],
+    lesion_id: str,
+    image_type: str,
+    isic_id: str,
+) -> dict[str, str]:
+    row = {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"
+    for key, value in NEUTRAL_METADATA.items():
+        if key in row:
+            row[key] = value
+    for column in columns:
+        if column.startswith("MONET_"):
+            row[column] = "0"
+    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
+    for class_column in LABEL_COLUMNS:
+        if class_column in row:
+            row[class_column] = "1.0" if class_column == class_name else "0.0"
+    return row
+
+
+def materialize_original_images(input_dir: Path, output_input_dir: Path, metadata_rows: list[dict[str, str]], copy_file: bool, overwrite: bool) -> None:
+    for row in metadata_rows:
+        src = original_image_path(input_dir, row)
+        dst = output_input_dir / row["lesion_id"] / f"{row['isic_id']}.jpg"
+        link_or_copy(src, dst, copy_file, overwrite)
+
+
+def materialize_synthetic_rows(
+    manifest_rows: list[dict[str, str]],
+    metadata_columns: list[str],
+    groundtruth_columns: list[str],
+    output_input_dir: Path,
+    copy_file: bool,
+    overwrite: bool,
+) -> tuple[list[dict[str, str]], list[dict[str, str]]]:
+    metadata_rows = []
+    groundtruth_rows = []
+    seen_lesions = set()
+
+    for row in manifest_rows:
+        lesion_id = row["synthetic_lesion_id"]
+        clinical_isic_id = row.get("clinical_synthetic_isic_id") or f"{lesion_id}__clinical"
+        dermoscopic_isic_id = row.get("dermoscopic_synthetic_isic_id") or f"{lesion_id}__dermoscopic"
+
+        clinical_dst = output_input_dir / lesion_id / f"{clinical_isic_id}.jpg"
+        dermoscopic_dst = output_input_dir / lesion_id / f"{dermoscopic_isic_id}.jpg"
+        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 lesion_id not in seen_lesions:
+            groundtruth_rows.append(synthetic_groundtruth_row(lesion_id, row["class_name"], groundtruth_columns))
+            seen_lesions.add(lesion_id)
+
+    return metadata_rows, groundtruth_rows
+
+
+def main() -> None:
+    args = parse_args()
+    input_dir = args.input_dir.expanduser().resolve()
+    metadata_csv = args.metadata_csv.expanduser().resolve()
+    groundtruth_csv = args.groundtruth_csv.expanduser().resolve()
+    augmentation_manifest = args.augmentation_manifest.expanduser().resolve()
+    output_dir = args.output_dir.expanduser().resolve()
+    output_input_dir = output_dir / "MILK10k_Training_Input"
+
+    metadata_rows = read_rows(metadata_csv)
+    groundtruth_rows = read_rows(groundtruth_csv)
+    manifest_rows = read_rows(augmentation_manifest)
+    if not manifest_rows:
+        raise ValueError(f"No augmentation rows found: {augmentation_manifest}")
+
+    metadata_columns = list(metadata_rows[0].keys())
+    groundtruth_columns = list(groundtruth_rows[0].keys())
+
+    copy_file = not args.symlink
+    materialize_original_images(input_dir, output_input_dir, metadata_rows, copy_file, args.overwrite)
+    synthetic_metadata_rows, synthetic_groundtruth_rows = materialize_synthetic_rows(
+        manifest_rows,
+        metadata_columns,
+        groundtruth_columns,
+        output_input_dir,
+        copy_file,
+        args.overwrite,
+    )
+
+    all_metadata_rows = metadata_rows + synthetic_metadata_rows
+    all_groundtruth_rows = groundtruth_rows + synthetic_groundtruth_rows
+    write_rows(output_dir / "MILK10k_Training_Metadata.csv", all_metadata_rows, metadata_columns)
+    write_rows(output_dir / "MILK10k_Training_GroundTruth.csv", all_groundtruth_rows, groundtruth_columns)
+
+    print("Materialized augmented MILK10k dataset")
+    print(f"  output_dir: {output_dir}")
+    print(f"  original metadata rows: {len(metadata_rows)}")
+    print(f"  synthetic metadata rows: {len(synthetic_metadata_rows)}")
+    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("")
+    print("Use this for training:")
+    print(f"  --data-dir {output_dir}")
+
+
+if __name__ == "__main__":
+    main()

Stable_diffusion_augmentation/merge_paired_augmentation_manifests.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""Merge paired augmentation manifests for training."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+from collections import Counter
+from pathlib import Path
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Merge paired augmentation manifests into one training manifest.")
+    parser.add_argument("--manifest", type=Path, action="append", required=True, help="Input manifest. Pass multiple times.")
+    parser.add_argument("--output", type=Path, required=True, help="Merged output manifest.")
+    parser.add_argument(
+        "--replace-class",
+        action="append",
+        default=[],
+        help="For this class, keep rows only from the last input manifest containing that class. Can be repeated.",
+    )
+    parser.add_argument("--dedupe", action="store_true", help="Drop duplicate synthetic_lesion_id rows, keeping later inputs.")
+    return parser.parse_args()
+
+
+def read_manifest(path: Path, input_index: int) -> list[dict[str, str]]:
+    with path.open(newline="") as f:
+        rows = list(csv.DictReader(f))
+    for row in rows:
+        row["_input_index"] = str(input_index)
+        row["_input_manifest"] = str(path)
+    return rows
+
+
+def class_counts(rows: list[dict[str, str]]) -> dict[str, int]:
+    return dict(sorted(Counter(row["class_name"] for row in rows).items()))
+
+
+def main() -> None:
+    args = parse_args()
+    manifests = [path.expanduser().resolve() for path in args.manifest]
+    for path in manifests:
+        if not path.exists():
+            raise FileNotFoundError(f"Manifest not found: {path}")
+
+    rows_by_input = [read_manifest(path, idx) for idx, path in enumerate(manifests)]
+    rows = [row for group in rows_by_input for row in group]
+    if not rows:
+        raise ValueError("No rows found in input manifests.")
+
+    replace_classes = set(args.replace_class)
+    if replace_classes:
+        last_input_for_class: dict[str, int] = {}
+        for row in rows:
+            class_name = row["class_name"]
+            if class_name in replace_classes:
+                last_input_for_class[class_name] = int(row["_input_index"])
+        rows = [
+            row
+            for row in rows
+            if row["class_name"] not in replace_classes
+            or int(row["_input_index"]) == last_input_for_class.get(row["class_name"])
+        ]
+
+    if args.dedupe:
+        by_id = {row["synthetic_lesion_id"]: row for row in rows}
+        rows = list(by_id.values())
+
+    output = args.output.expanduser().resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    fieldnames = [key for key in rows[0].keys() if not key.startswith("_")]
+    with output.open("w", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for row in rows:
+            writer.writerow({key: row.get(key, "") for key in fieldnames})
+
+    print("Merged paired augmentation manifests")
+    for path, group in zip(manifests, rows_by_input):
+        print(f"  input: {path}")
+        print(f"    rows={len(group)}, classes={class_counts(group)}")
+    print(f"  output: {output}")
+    print(f"    rows={len(rows)}, classes={class_counts(rows)}")
+
+
+if __name__ == "__main__":
+    main()