scripts/serving/inference_4k.py

"""
4K Image Generation Pipeline:
  1. Generate 1024px with fine-tuned Flux Dev LoRA
  2. Upscale to 4096px with Real-ESRGAN x4

Usage:
  python3 inference_4k.py --prompt "a beautiful landscape" --output output.png
  python3 inference_4k.py --prompt "a cat" --lora-path /path/to/checkpoint --output cat_4k.png
"""
import argparse
import time
from pathlib import Path

import torch
import numpy as np
from PIL import Image


def load_flux_pipeline(model_name, lora_path=None, device="cuda:0", dtype=torch.bfloat16):
    from diffusers import FluxPipeline

    print(f"  Loading Flux Dev pipeline...")
    pipe = FluxPipeline.from_pretrained(
        model_name,
        torch_dtype=dtype,
    )

    if lora_path:
        lora_path = Path(lora_path)
        if (lora_path / "adapter_model.safetensors").exists():
            pipe.load_lora_weights(str(lora_path))
            print(f"  Loaded LoRA from {lora_path}")
        else:
            print(f"  WARNING: No adapter_model.safetensors in {lora_path}")

    pipe = pipe.to(device)
    pipe.enable_model_cpu_offload()
    return pipe


def load_realesrgan(device="cuda:0", scale=4):
    """Load Real-ESRGAN x4 model for upscaling."""
    try:
        from realesrgan import RealESRGANer
        from basicsr.archs.rrdbnet_arch import RRDBNet
    except ImportError:
        print("  Installing Real-ESRGAN...")
        import subprocess
        subprocess.run([
            "pip3", "install", "-q",
            "realesrgan", "basicsr", "facexlib", "gfpgan"
        ], check=True)
        from realesrgan import RealESRGANer
        from basicsr.archs.rrdbnet_arch import RRDBNet

    model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=scale)

    model_path = Path("/data0/models/RealESRGAN_x4plus.pth")
    if not model_path.exists():
        print("  Downloading RealESRGAN_x4plus model...")
        model_path.parent.mkdir(parents=True, exist_ok=True)
        import urllib.request
        urllib.request.urlretrieve(
            "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth",
            str(model_path),
        )

    upsampler = RealESRGANer(
        scale=scale,
        model_path=str(model_path),
        model=model,
        tile=512,
        tile_pad=10,
        pre_pad=0,
        half=True,
        device=device,
    )
    print(f"  Real-ESRGAN x{scale} loaded")
    return upsampler


def generate_1k(pipe, prompt, num_steps=28, guidance_scale=3.5, seed=None):
    """Generate 1024x1024 image with Flux Dev."""
    generator = None
    if seed is not None:
        generator = torch.Generator(device=pipe.device).manual_seed(seed)

    image = pipe(
        prompt=prompt,
        num_inference_steps=num_steps,
        guidance_scale=guidance_scale,
        height=1024,
        width=1024,
        generator=generator,
    ).images[0]

    return image


def upscale_4k(upsampler, image):
    """Upscale PIL image to 4K using Real-ESRGAN."""
    import cv2

    img_np = np.array(image)
    img_bgr = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)

    output, _ = upsampler.enhance(img_bgr, outscale=4)

    output_rgb = cv2.cvtColor(output, cv2.COLOR_BGR2RGB)
    return Image.fromarray(output_rgb)


def main():
    parser = argparse.ArgumentParser(description="Generate 4K images")
    parser.add_argument("--prompt", type=str, required=True)
    parser.add_argument("--output", type=str, default="output_4k.png")
    parser.add_argument("--model-name", default="black-forest-labs/FLUX.1-dev")
    parser.add_argument("--lora-path", type=str, default=None)
    parser.add_argument("--num-steps", type=int, default=28)
    parser.add_argument("--guidance-scale", type=float, default=3.5)
    parser.add_argument("--seed", type=int, default=None)
    parser.add_argument("--device", default="cuda:0")
    parser.add_argument("--skip-upscale", action="store_true")
    parser.add_argument("--save-1k", action="store_true", help="Also save 1K intermediate")
    args = parser.parse_args()

    t0 = time.time()

    # Stage 1: Generate 1024px
    print("=== Stage 1: Generate 1024px ===")
    pipe = load_flux_pipeline(args.model_name, args.lora_path, args.device)
    image_1k = generate_1k(pipe, args.prompt, args.num_steps, args.guidance_scale, args.seed)
    print(f"  Generated 1024x1024 in {time.time()-t0:.1f}s")

    if args.save_1k:
        path_1k = Path(args.output).with_suffix("").with_name(Path(args.output).stem + "_1k.png")
        image_1k.save(path_1k)
        print(f"  Saved 1K: {path_1k}")

    # Free GPU memory
    del pipe
    torch.cuda.empty_cache()

    if args.skip_upscale:
        image_1k.save(args.output)
        print(f"  Saved (no upscale): {args.output}")
        return

    # Stage 2: Upscale to 4K
    print("=== Stage 2: Upscale to 4096px ===")
    t1 = time.time()
    upsampler = load_realesrgan(args.device)
    image_4k = upscale_4k(upsampler, image_1k)
    print(f"  Upscaled to {image_4k.size[0]}x{image_4k.size[1]} in {time.time()-t1:.1f}s")

    # Save
    output_path = Path(args.output)
    output_path.parent.mkdir(parents=True, exist_ok=True)
    image_4k.save(output_path, quality=95)
    print(f"\n  Final 4K image saved: {output_path}")
    print(f"  Total time: {time.time()-t0:.1f}s")


if __name__ == "__main__":
    main()