| import os, sys, math, dataclasses, csv |
| import numpy as np, torch |
| from PIL import Image |
| from omegaconf import OmegaConf |
| from configs.stage2 import Stage2Config |
| from stage2.transport import create_sampler, create_transport |
| from utils.guidance_utils import get_model_forward_fn |
| from utils.model_utils import instantiate_from_config |
|
|
| CFG_PATH = sys.argv[1] |
| OUTDIR = sys.argv[2] |
| NPER = int(sys.argv[3]) if len(sys.argv) > 3 else 2000 |
| BATCH = int(sys.argv[4]) if len(sys.argv) > 4 else 50 |
| ALLCLASSES = ["CNV", "DME", "DRUSEN", "NORMAL"] |
| CLASSES = sys.argv[5].split(",") if len(sys.argv) > 5 else ALLCLASSES |
| TAG = sys.argv[6] if len(sys.argv) > 6 else "all" |
| device = torch.device("cuda", 0) |
| torch.set_grad_enabled(False) |
| torch.backends.cuda.matmul.allow_tf32 = True; torch.backends.cudnn.allow_tf32 = True |
|
|
| config = OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(Stage2Config), OmegaConf.load(CFG_PATH))) |
| config.post_process() |
| latent_size = tuple(config.misc.latent_size) |
| rae = instantiate_from_config(config.stage_1).to(device).eval() |
| config.prepare_model_params() |
| model = instantiate_from_config(config.stage_2).to(device).eval() |
| model_fn, sample_model_kwargs = get_model_forward_fn(model, config.guidance) |
| use_guidance = config.guidance.any_guidance_active |
| null_label = config.misc.num_classes |
| tds = math.sqrt((config.misc.time_dist_shift_dim or math.prod(latent_size)) / config.misc.time_dist_shift_base) |
| transport = create_transport(config=config.transport, time_dist_shift=tds) |
| sampler = create_sampler(transport, guidance_config=config.guidance) |
| sample_fn = sampler.sample_ode(**dataclasses.asdict(config.sampler)) |
| print(f"setup ok; latent={latent_size} use_guidance={use_guidance} ckpt={config.stage_2.ckpt}", flush=True) |
|
|
| os.makedirs(OUTDIR, exist_ok=True) |
| rows = [] |
| for c in CLASSES: |
| ci = ALLCLASSES.index(c) |
| cdir = os.path.join(OUTDIR, "images", c); os.makedirs(cdir, exist_ok=True) |
| done = 0 |
| while done < NPER: |
| n = min(BATCH, NPER - done) |
| z = torch.randn(n, *latent_size, device=device) |
| context = torch.full((n,), ci, device=device, dtype=torch.long) |
| if use_guidance: |
| z = torch.cat([z, z], dim=0) |
| context = torch.cat([context, torch.full((n,), null_label, device=device, dtype=torch.long)], dim=0) |
| mk = dict(context=context, attn_mask=None, **sample_model_kwargs) |
| with torch.autocast("cuda", dtype=torch.bfloat16): |
| samples = sample_fn(z, model_fn, **mk)[-1] |
| if use_guidance: |
| samples = samples.chunk(2, dim=0)[0] |
| imgs = rae.decode(samples).clamp(0, 1) |
| arr = imgs.mul(255).permute(0, 2, 3, 1).to("cpu", dtype=torch.uint8).numpy() |
| for j in range(n): |
| rel = f"images/{c}/{c}_{done+j:05d}.png" |
| Image.fromarray(arr[j]).save(os.path.join(OUTDIR, rel)) |
| rows.append((os.path.join(OUTDIR, rel), c)) |
| done += n |
| print(f"{c}: {done} (std={arr.std():.0f})", flush=True) |
| with open(os.path.join(OUTDIR, f"synth_{TAG}.csv"), "w", newline="") as f: |
| w = csv.writer(f); w.writerow(["image_path", "dx"]); w.writerows(rows) |
| print(f"SAMPLE_PERCLASS_DONE tag={TAG} n={len(rows)}", flush=True) |
|
|
