code/OCT_RAE_main/src/sample_conditional.py

"""
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()