File size: 5,214 Bytes
32da3e8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 | """
Conditional sampling script for class-conditional generation with RAE.
Supports multiple CFG scales and per-class sampling.
"""
import argparse
import math
import os
import sys
import torch
from pathlib import Path
from torchvision.utils import save_image
from utils.model_utils import instantiate_from_config
from utils.train_utils import parse_configs
from stage1 import RAE
from stage2.models import Stage2ModelProtocol
from stage2.transport import create_transport, Sampler
torch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.allow_tf32 = True
def main():
parser = argparse.ArgumentParser(description='Conditional sampling from trained RAE+DiT')
parser.add_argument('--config', type=str, required=True)
parser.add_argument('--output-dir', type=str, default='samples')
parser.add_argument('--num-per-class', type=int, default=50)
parser.add_argument('--cfg-scales', type=float, nargs='+', default=[1.0, 2.0, 3.0])
parser.add_argument('--seed', type=int, default=42)
parser.add_argument('--batch-size', type=int, default=25)
parser.add_argument('--device', type=str, default='cuda')
parser.add_argument('--precision', type=str, default='bf16', choices=['fp32', 'bf16'])
args = parser.parse_args()
torch.manual_seed(args.seed)
device = torch.device(args.device)
# Load config
rae_config, model_config, transport_config, sampler_config, guidance_config, misc, _, _ = parse_configs(args.config)
# Build models
rae: RAE = instantiate_from_config(rae_config).to(device).eval()
model: Stage2ModelProtocol = instantiate_from_config(model_config).to(device).eval()
num_classes = int(misc.get('num_classes', 8))
latent_size = tuple(int(d) for d in misc.get('latent_size', [768, 16, 16]))
null_label = num_classes # null class for CFG
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 and sampler
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_mode = sampler_config.get('mode', 'ODE')
sampler_params = dict(sampler_config.get('params', {}))
if sampler_mode == 'ODE':
sample_fn = sampler.sample_ode(**sampler_params)
else:
sample_fn = sampler.sample_sde(**sampler_params)
# Class names (OCT8 dataset, sorted alphabetically as ImageFolder does)
class_names = ['AMD', 'CSC', 'DR', 'ERM', 'MH', 'MS', 'NORMAL', 'ROVs']
use_bf16 = args.precision == 'bf16'
autocast_kwargs = dict(dtype=torch.bfloat16 if use_bf16 else torch.float32, enabled=use_bf16)
for cfg_scale in args.cfg_scales:
print(f'\n=== Sampling with CFG scale = {cfg_scale} ===')
for class_idx in range(num_classes):
class_name = class_names[class_idx] if class_idx < len(class_names) 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)
num_generated = 0
batch_idx = 0
while num_generated < args.num_per_class:
n = min(args.batch_size, args.num_per_class - num_generated)
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:
# CFG: duplicate z and y
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)
model_kwargs = dict(
y=y_cfg,
cfg_scale=cfg_scale,
cfg_interval=(0.0, 1.0),
)
samples = sample_fn(z_cfg, model.forward_with_cfg, **model_kwargs)[-1]
samples = samples[:n] # take conditional half
else:
# No guidance
model_kwargs = dict(y=y)
samples = sample_fn(z, model.forward, **model_kwargs)[-1]
samples = samples.float()
images = rae.decode(samples)
images = images.clamp(0, 1)
for i in range(n):
img_path = save_dir / f'{num_generated + i:04d}.png'
save_image(images[i], str(img_path))
num_generated += n
batch_idx += 1
print(f' {class_name}: {num_generated} images saved to {save_dir}')
print('\nDone!')
if __name__ == '__main__':
main()
|