Upload 15 files

Stable_diffusion_augmentation/README.md

@@ -85,6 +85,14 @@ Cài dependency:
 pip install torch diffusers transformers accelerate pillow tqdm
 ```
 
+Nếu gặp lỗi kiểu `No module named 'flash_attn.flash_attn_interface'`, thường là do `xformers` bị lệch với Python/torch. Với pipeline này `xformers` là optional, cách sửa nhanh là gỡ nó:
+
+```bash
+pip uninstall -y xformers flash-attn
+```
+
+Trên Python 3.13, nên chạy trước không có `xformers`; script vẫn bật attention slicing trên CUDA.
+
 Sinh ảnh clinical cho class `MEL`:
 
 ```bash

Stable_diffusion_augmentation/generate_milk10k_sd.py

@@ -120,6 +120,11 @@ def parse_args() -> argparse.Namespace:
         ),
     )
     parser.add_argument("--fp32", action="store_true", help="Use float32 instead of fp16 on CUDA.")
+    parser.add_argument(
+        "--allow-black-images",
+        action="store_true",
+        help="Allow nearly black outputs. By default these fail because they usually mean safety-checker blocking.",
+    )
     parser.add_argument(
         "--disable-safety-checker",
         action="store_true",
@@ -179,7 +184,18 @@ def load_class_rows(data_dir: Path, class_name: str, image_type: str) -> list[di
 
 def load_pipeline(args: argparse.Namespace):
     import torch
-    from diffusers import StableDiffusionImg2ImgPipeline
+    try:
+        from diffusers import StableDiffusionImg2ImgPipeline
+    except RuntimeError as exc:
+        message = str(exc)
+        if "flash_attn.flash_attn_interface" in message or "xformers" in message:
+            raise RuntimeError(
+                "Diffusers failed while importing xformers/flash-attn. xformers is optional for this script; "
+                "your install appears broken. Fix with:\n\n"
+                "  pip uninstall -y xformers flash-attn\n\n"
+                "Then rerun. The script still enables attention slicing on CUDA."
+            ) from exc
+        raise
 
     model_id = resolve_model_id(args)
     device = "cuda" if torch.cuda.is_available() else "cpu"
@@ -215,6 +231,14 @@ def prepare_image(path: Path, size: int) -> Image.Image:
         return ImageOps.fit(img, (size, size), method=Image.Resampling.LANCZOS)
 
 
+def looks_like_blocked_black_image(image: Image.Image) -> bool:
+    stat_image = image.convert("L").resize((32, 32), method=Image.Resampling.BILINEAR)
+    pixels = list(stat_image.getdata())
+    mean_value = sum(pixels) / max(len(pixels), 1)
+    bright_pixels = sum(1 for value in pixels if value > 8)
+    return mean_value < 3.0 and bright_pixels / max(len(pixels), 1) < 0.01
+
+
 def main() -> None:
     args = parse_args()
     import torch
@@ -228,6 +252,11 @@ def main() -> None:
     output_dir = args.output_dir.expanduser().resolve()
     image_dir = output_dir / args.class_name / args.image_type
     image_dir.mkdir(parents=True, exist_ok=True)
+    if not args.disable_safety_checker:
+        print(
+            "Warning: diffusers safety checker is enabled. Clinical/dermoscopic skin images may be falsely "
+            "blocked and returned as black images. If that happens, rerun with --disable-safety-checker."
+        )
 
     rows = load_class_rows(data_dir, args.class_name, args.image_type)
     if args.shuffle:
@@ -279,7 +308,15 @@ def main() -> None:
                 )
                 out_name = f"{row['lesion_id']}_{row['isic_id']}_sd_{aug_idx:02d}_seed{seed}.jpg"
                 out_path = image_dir / out_name
-                result.images[0].save(out_path, quality=95)
+                image = result.images[0]
+                if not args.allow_black_images and looks_like_blocked_black_image(image):
+                    raise RuntimeError(
+                        "Stable Diffusion returned a nearly black image. This usually means the default safety checker "
+                        "blocked a clinical skin image as NSFW. Rerun with:\n\n"
+                        "  --disable-safety-checker\n\n"
+                        f"Blocked output path would have been: {out_path}"
+                    )
+                image.save(out_path, quality=95)
 
                 writer.writerow(
                     {

Stable_diffusion_augmentation/generate_milk10k_sd_pairs.py

@@ -26,6 +26,7 @@ ImageFile.LOAD_TRUNCATED_IMAGES = True
 
 DEFAULT_MINORITY_CLASSES = ["MAL_OTH", "BEN_OTH", "VASC", "INF", "DF"]
 MODALITIES = ("clinical_close_up", "dermoscopic")
+IMAGE_EXTENSIONS = (".jpg", ".jpeg", ".png", ".JPG", ".JPEG", ".PNG")
 NEUTRAL_METADATA = {
     "age_approx": "",
     "sex": "unknown",
@@ -80,6 +81,12 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--clinical-lora-scale", type=float, default=1.0)
     parser.add_argument("--dermoscopic-lora-scale", type=float, default=1.0)
     parser.add_argument("--skip-existing", action="store_true", help="Do not regenerate images that already exist.")
+    parser.add_argument("--diagnose-data", action="store_true", help="Print data matching diagnostics and exit before diffusion.")
+    parser.add_argument(
+        "--allow-black-images",
+        action="store_true",
+        help="Allow nearly black outputs. By default these fail because they usually mean the safety checker blocked a medical skin image.",
+    )
     parser.add_argument("--fp32", action="store_true", help="Use float32 instead of fp16 on CUDA.")
     parser.add_argument("--disable-safety-checker", action="store_true")
     return parser.parse_args()
@@ -114,10 +121,34 @@ def read_labels(gt_path: Path) -> dict[str, str]:
     return labels
 
 
+def resolve_source_image(input_dir: Path, lesion_id: str, isic_id: str) -> Path | None:
+    for suffix in IMAGE_EXTENSIONS:
+        path = input_dir / lesion_id / f"{isic_id}{suffix}"
+        if path.exists():
+            return path
+    return None
+
+
 def load_paired_rows(input_dir: Path, gt_path: Path, meta_path: Path, class_names: list[str]) -> tuple[list[dict[str, str]], list[str]]:
+    paired, metadata_columns, diagnostics = load_paired_rows_with_diagnostics(input_dir, gt_path, meta_path, class_names)
+    if not paired:
+        raise ValueError(format_diagnostics_error(class_names, input_dir, gt_path, meta_path, diagnostics))
+    return paired, metadata_columns
+
+
+def load_paired_rows_with_diagnostics(
+    input_dir: Path,
+    gt_path: Path,
+    meta_path: Path,
+    class_names: list[str],
+) -> tuple[list[dict[str, str]], list[str], dict[str, object]]:
     labels = read_labels(gt_path)
     selected = {lesion_id for lesion_id, label in labels.items() if label in class_names}
     by_lesion: dict[str, dict[str, dict[str, str]]] = {}
+    metadata_rows_by_class: Counter[str] = Counter()
+    metadata_modality_by_class: Counter[tuple[str, str]] = Counter()
+    existing_modality_by_class: Counter[tuple[str, str]] = Counter()
+    missing_source_examples: list[str] = []
 
     with meta_path.open(newline="") as f:
         reader = csv.DictReader(f)
@@ -126,12 +157,18 @@ def load_paired_rows(input_dir: Path, gt_path: Path, meta_path: Path, class_name
             lesion_id = row["lesion_id"]
             if lesion_id not in selected:
                 continue
+            class_name = labels[lesion_id]
+            metadata_rows_by_class[class_name] += 1
             image_type = normalize_image_type(row["image_type"])
+            metadata_modality_by_class[(class_name, image_type)] += 1
             if image_type not in MODALITIES:
                 continue
-            source_path = input_dir / lesion_id / f"{row['isic_id']}.jpg"
-            if not source_path.exists():
+            source_path = resolve_source_image(input_dir, lesion_id, row["isic_id"])
+            if source_path is None:
+                if len(missing_source_examples) < 8:
+                    missing_source_examples.append(str(input_dir / lesion_id / f"{row['isic_id']}.jpg"))
                 continue
+            existing_modality_by_class[(class_name, image_type)] += 1
             copied = dict(row)
             copied["source_path"] = str(source_path)
             copied["image_type_norm"] = image_type
@@ -151,9 +188,71 @@ def load_paired_rows(input_dir: Path, gt_path: Path, meta_path: Path, class_name
                 }
             )
 
-    if not paired:
-        raise ValueError(f"No paired clinical/dermoscopic lesions found for classes: {', '.join(class_names)}")
-    return sorted(paired, key=lambda row: (row["class_name"], row["lesion_id"])), metadata_columns
+    diagnostics = {
+        "labels_by_target_class": dict(sorted(Counter(label for label in labels.values() if label in class_names).items())),
+        "selected_lesions": len(selected),
+        "metadata_rows_by_class": dict(sorted(metadata_rows_by_class.items())),
+        "metadata_modality_by_class": {
+            f"{class_name}/{modality}": count
+            for (class_name, modality), count in sorted(metadata_modality_by_class.items())
+        },
+        "existing_modality_by_class": {
+            f"{class_name}/{modality}": count
+            for (class_name, modality), count in sorted(existing_modality_by_class.items())
+        },
+        "lesions_with_any_existing_modality": len(by_lesion),
+        "paired_lesions_by_class": class_counts(paired),
+        "missing_source_examples": missing_source_examples,
+    }
+    return sorted(paired, key=lambda row: (row["class_name"], row["lesion_id"])), metadata_columns, diagnostics
+
+
+def format_diagnostics_error(
+    class_names: list[str],
+    input_dir: Path,
+    gt_path: Path,
+    meta_path: Path,
+    diagnostics: dict[str, object],
+) -> str:
+    lines = [
+        f"No paired clinical/dermoscopic lesions found for classes: {', '.join(class_names)}",
+        "",
+        "Data diagnostics:",
+        f"  input_dir={input_dir}",
+        f"  groundtruth_csv={gt_path}",
+        f"  metadata_csv={meta_path}",
+        f"  labels_by_target_class={diagnostics['labels_by_target_class']}",
+        f"  selected_lesions={diagnostics['selected_lesions']}",
+        f"  metadata_rows_by_class={diagnostics['metadata_rows_by_class']}",
+        f"  metadata_modality_by_class={diagnostics['metadata_modality_by_class']}",
+        f"  existing_modality_by_class={diagnostics['existing_modality_by_class']}",
+        f"  lesions_with_any_existing_modality={diagnostics['lesions_with_any_existing_modality']}",
+        f"  paired_lesions_by_class={diagnostics['paired_lesions_by_class']}",
+    ]
+    missing = diagnostics.get("missing_source_examples") or []
+    if missing:
+        lines.append("  missing_source_examples=")
+        lines.extend(f"    {path}" for path in missing)
+    lines.extend(
+        [
+            "",
+            "Most likely fix: pass the real training image root via --input-dir.",
+            "Expected image layout: <input-dir>/<lesion_id>/<isic_id>.jpg",
+        ]
+    )
+    return "\n".join(lines)
+
+
+def print_data_diagnostics(input_dir: Path, gt_path: Path, meta_path: Path, class_names: list[str]) -> None:
+    rows, metadata_columns, diagnostics = load_paired_rows_with_diagnostics(input_dir, gt_path, meta_path, class_names)
+    print("Data diagnostics")
+    print(f"  input_dir={input_dir}")
+    print(f"  groundtruth_csv={gt_path}")
+    print(f"  metadata_csv={meta_path}")
+    print(f"  metadata_columns={len(metadata_columns)}")
+    for key, value in diagnostics.items():
+        print(f"  {key}={value}")
+    print(f"  paired_rows={len(rows)}")
 
 
 def select_rows(rows: list[dict[str, str]], class_names: list[str], max_source_lesions: int | None, shuffle: bool, seed: int):
@@ -288,7 +387,20 @@ def log_generation_plan(
 
 def load_pipeline(args: argparse.Namespace, lora_weights: Path | None, lora_scale: float):
     import torch
-    from diffusers import StableDiffusionImg2ImgPipeline
+    try:
+        from diffusers import StableDiffusionImg2ImgPipeline
+    except RuntimeError as exc:
+        message = str(exc)
+        if "flash_attn.flash_attn_interface" in message or "xformers" in message:
+            raise RuntimeError(
+                "Diffusers failed while importing xformers/flash-attn. Your environment likely has a broken "
+                "xformers install. For this SD 1.5 img2img script, xformers is optional; uninstall it and rerun:\n\n"
+                "  pip uninstall -y xformers flash-attn\n\n"
+                "Then keep using attention slicing, which this script enables automatically on CUDA. "
+                "If you really need xformers, use a Python 3.10/3.11 CUDA environment with matching torch, "
+                "xformers, and flash-attn wheels."
+            ) from exc
+        raise
 
     device = "cuda" if torch.cuda.is_available() else "cpu"
     dtype = torch.float32 if device == "cpu" or args.fp32 else torch.float16
@@ -316,6 +428,14 @@ def prepare_image(path: Path, size: int) -> Image.Image:
         return ImageOps.fit(img.convert("RGB"), (size, size), method=Image.Resampling.LANCZOS)
 
 
+def looks_like_blocked_black_image(image: Image.Image) -> bool:
+    stat_image = image.convert("L").resize((32, 32), method=Image.Resampling.BILINEAR)
+    pixels = list(stat_image.getdata())
+    mean_value = sum(pixels) / max(len(pixels), 1)
+    bright_pixels = sum(1 for value in pixels if value > 8)
+    return mean_value < 3.0 and bright_pixels / max(len(pixels), 1) < 0.01
+
+
 def modality_prompt(args: argparse.Namespace, class_name: str, modality: str) -> str:
     if modality == "clinical_close_up" and args.clinical_prompt:
         return args.clinical_prompt
@@ -361,7 +481,15 @@ def generate_modality(tasks: list[dict[str, str | int]], args: argparse.Namespac
             num_inference_steps=args.steps,
             generator=generator,
         )
-        result.images[0].save(out_path, quality=95)
+        image = result.images[0]
+        if not args.allow_black_images and looks_like_blocked_black_image(image):
+            raise RuntimeError(
+                "Stable Diffusion returned a nearly black image. This usually means the default safety checker "
+                "blocked a clinical skin image as NSFW. Rerun with:\n\n"
+                "  --disable-safety-checker\n\n"
+                f"Blocked output path would have been: {out_path}"
+            )
+        image.save(out_path, quality=95)
         generated += 1
 
     del pipe
@@ -480,8 +608,17 @@ def main() -> None:
         raise ValueError("--strength must be in [0, 1]")
 
     args.output_dir = args.output_dir.expanduser().resolve()
+    if not args.disable_safety_checker:
+        print(
+            "Warning: diffusers safety checker is enabled. Clinical/dermoscopic skin images may be falsely "
+            "blocked and returned as black images. If that happens, rerun with --disable-safety-checker."
+        )
 
     input_dir, gt_path, meta_path = resolve_data_paths(args)
+    if args.diagnose_data:
+        print_data_diagnostics(input_dir, gt_path, meta_path, args.class_names)
+        return
+
     all_rows, metadata_columns = load_paired_rows(input_dir, gt_path, meta_path, args.class_names)
     rows = select_rows(all_rows, args.class_names, args.max_source_lesions, args.shuffle, args.seed)
     tasks = build_tasks(rows, args)

Stable_diffusion_augmentation/requirements.txt

@@ -0,0 +1,12 @@
+torch
+torchvision
+diffusers
+transformers
+accelerate
+safetensors
+pillow
+tqdm
+pandas
+numpy
+scikit-learn
+timm