| |
| """Conditional sampling for Kermany2018 class names using OCT RAE-main.""" |
| from __future__ import annotations |
|
|
| import argparse |
| import math |
| from pathlib import Path |
|
|
| import torch |
| from torchvision.utils import save_image |
|
|
| from stage1 import RAE |
| from stage2.models import Stage2ModelProtocol |
| from stage2.transport import create_transport, Sampler |
| from utils.model_utils import instantiate_from_config |
| from utils.train_utils import parse_configs |
|
|
|
|
| CLASSES = ["CNV", "DME", "DRUSEN", "NORMAL"] |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--config", required=True) |
| parser.add_argument("--output-dir", default="samples") |
| parser.add_argument("--num-per-class", type=int, default=2000) |
| parser.add_argument("--cfg-scales", type=float, nargs="+", default=[1.0]) |
| parser.add_argument("--seed", type=int, default=42) |
| parser.add_argument("--batch-size", type=int, default=50) |
| parser.add_argument("--device", default="cuda") |
| parser.add_argument("--precision", choices=["fp32", "bf16"], default="bf16") |
| args = parser.parse_args() |
|
|
| torch.manual_seed(args.seed) |
| device = torch.device(args.device) |
|
|
| rae_config, model_config, transport_config, sampler_config, _, misc, _, _ = parse_configs(args.config) |
| rae: RAE = instantiate_from_config(rae_config).to(device).eval() |
| model: Stage2ModelProtocol = instantiate_from_config(model_config).to(device).eval() |
|
|
| ckpt = model_config.get("ckpt", None) |
| if ckpt is None: |
| raise ValueError("stage_2.ckpt is required in the sampling config") |
| state = torch.load(ckpt, map_location="cpu", weights_only=False) |
| model.load_state_dict(state.get("ema", state.get("model", state)), strict=True) |
|
|
| num_classes = int(misc.get("num_classes", len(CLASSES))) |
| latent_size = tuple(int(d) for d in misc.get("latent_size")) |
| null_label = num_classes |
| shift_dim = misc.get("time_dist_shift_dim", math.prod(latent_size)) |
| shift_base = misc.get("time_dist_shift_base", 4096) |
| time_dist_shift = math.sqrt(shift_dim / shift_base) |
|
|
| transport_params = dict(transport_config.get("params", {})) |
| transport_params.pop("time_dist_shift", None) |
| transport = create_transport(**transport_params, time_dist_shift=time_dist_shift) |
| sampler = Sampler(transport) |
| sampler_params = dict(sampler_config.get("params", {})) |
| if sampler_config.get("mode", "ODE").upper() == "ODE": |
| sample_fn = sampler.sample_ode(**sampler_params) |
| else: |
| sample_fn = sampler.sample_sde(**sampler_params) |
|
|
| use_bf16 = args.precision == "bf16" |
| autocast_kwargs = dict(dtype=torch.bfloat16, enabled=use_bf16) |
|
|
| for cfg_scale in args.cfg_scales: |
| for class_idx in range(num_classes): |
| class_name = CLASSES[class_idx] if class_idx < len(CLASSES) else f"class_{class_idx}" |
| save_dir = Path(args.output_dir) / f"cfg_{cfg_scale}" / class_name |
| save_dir.mkdir(parents=True, exist_ok=True) |
|
|
| made = 0 |
| while made < args.num_per_class: |
| n = min(args.batch_size, args.num_per_class - made) |
| z = torch.randn(n, *latent_size, device=device) |
| y = torch.full((n,), class_idx, device=device, dtype=torch.long) |
|
|
| with torch.no_grad(), torch.cuda.amp.autocast(**autocast_kwargs): |
| if cfg_scale > 1.0: |
| z_cfg = torch.cat([z, z], dim=0) |
| y_null = torch.full((n,), null_label, device=device, dtype=torch.long) |
| y_cfg = torch.cat([y, y_null], dim=0) |
| samples = sample_fn( |
| z_cfg, |
| model.forward_with_cfg, |
| y=y_cfg, |
| cfg_scale=cfg_scale, |
| cfg_interval=(0.0, 1.0), |
| )[-1][:n] |
| else: |
| samples = sample_fn(z, model.forward, y=y)[-1] |
| images = rae.decode(samples.float()).clamp(0, 1) |
|
|
| for i in range(n): |
| save_image(images[i], save_dir / f"{made + i:04d}.png") |
| made += n |
| print(f"{class_name}: {made} images saved to {save_dir}", flush=True) |
| print("KERMANY_SAMPLING_DONE") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
