infer_folder.py

import argparse
import math
import os
import sys
import time
from pathlib import Path

import numpy as np
import torch
from PIL import Image
from torchvision import transforms

import dist
from models import build_var
from myutils.wavelet_color_fix import adain_color_fix
from utils import arg_util


def parse_folder_args():
    parser = argparse.ArgumentParser(
        description="Run VARSR xN inference on every image in a folder.",
        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
    )
    parser.add_argument("--input_dir", required=True, help="Folder containing LR images.")
    parser.add_argument("--output_dir", required=True, help="Folder for VARSR outputs.")
    parser.add_argument("--scale", type=float, default=4.0, help="Super-resolution scale.")
    parser.add_argument("--cfg", type=float, default=7.0, help="Classifier-free guidance scale.")
    parser.add_argument("--top_k", type=int, default=1)
    parser.add_argument("--top_p", type=float, default=0.75)
    parser.add_argument("--tile_size", type=int, default=32, help="Tile size in latent cells. 32 means 512 px.")
    parser.add_argument("--tile_overlap", type=int, default=8, help="Tile overlap in latent cells.")
    parser.add_argument("--extensions", default=".png,.jpg,.jpeg,.JPG,.JPEG", help="Comma-separated image extensions.")
    parser.add_argument("--save_ext", default="", help="Optional output extension, e.g. .png. Empty keeps input suffix.")
    parser.add_argument("--limit", type=int, default=0, help="Only process the first N images when > 0.")
    parser.add_argument("--overwrite", action="store_true", help="Overwrite existing outputs.")
    parser.add_argument("--no_color_fix", action="store_true", help="Disable AdaIN color correction.")
    folder_args, remaining = parser.parse_known_args()
    sys.argv = [sys.argv[0]] + remaining
    return folder_args


def numpy_to_pil(images: np.ndarray):
    if images.ndim == 3:
        images = images[None, ...]
    images = (images * 255).round().clip(0, 255).astype("uint8")
    if images.shape[-1] == 1:
        return [Image.fromarray(image.squeeze(), mode="L") for image in images]
    return [Image.fromarray(image) for image in images]


def pt_to_numpy(images: torch.Tensor) -> np.ndarray:
    return images.cpu().permute(0, 2, 3, 1).float().numpy()


def gaussian_weights(tile_width, tile_height, nbatches, device):
    var = 0.01
    x_mid = (tile_width - 1) / 2
    y_mid = tile_height / 2
    x_probs = [
        math.exp(-((x - x_mid) ** 2) / (tile_width * tile_width) / (2 * var)) / math.sqrt(2 * math.pi * var)
        for x in range(tile_width)
    ]
    y_probs = [
        math.exp(-((y - y_mid) ** 2) / (tile_height * tile_height) / (2 * var)) / math.sqrt(2 * math.pi * var)
        for y in range(tile_height)
    ]
    weights = np.outer(y_probs, x_probs)
    return torch.tile(torch.tensor(weights, device=device), (nbatches, 32, 1, 1))


def iter_images(input_dir: Path, extensions, limit: int):
    allowed = {ext if ext.startswith(".") else f".{ext}" for ext in extensions}
    paths = sorted(path for path in input_dir.rglob("*") if path.is_file() and path.suffix in allowed)
    if limit > 0:
        paths = paths[:limit]
    return paths


def build_models(args):
    args.depth = 24
    vae, var = build_var(
        V=4096,
        Cvae=32,
        ch=160,
        share_quant_resi=4,
        controlnet_depth=args.depth,
        device=dist.get_device(),
        patch_nums=args.patch_nums,
        control_patch_nums=args.patch_nums,
        num_classes=2,
        depth=args.depth,
        shared_aln=args.saln,
        attn_l2_norm=args.anorm,
        flash_if_available=args.fuse,
        fused_if_available=args.fuse,
        init_adaln=args.aln,
        init_adaln_gamma=args.alng,
        init_head=args.hd,
        init_std=args.ini,
    )
    vae_state = torch.load(args.vae_model_path, map_location="cpu")
    var_state = torch.load(args.var_test_path, map_location="cpu")
    vae.load_state_dict(vae_state["trainer"]["vae_local"], strict=True)
    var.load_state_dict(var_state["trainer"]["var_wo_ddp"], strict=True)
    vae.eval()
    var.eval()
    return vae, var


def grid_count(length, tile_size, tile_overlap):
    count = 0
    cur = 0
    while cur < length:
        cur = max(count * tile_size - tile_overlap * count, 0) + tile_size
        count += 1
    return count


def resolve_one(image_path, output_path, vae, var, folder_args, device):
    img_preproc = transforms.ToTensor()
    scale = folder_args.scale
    rscale_int = int(scale)
    if not math.isclose(scale, rscale_int):
        raise ValueError("This script expects an integer scale because VARSR tile inference was authored for integer xN SR.")

    lr_image = Image.open(image_path).convert("RGB")
    src_w, src_h = lr_image.size
    target_w = int(round(src_w * scale))
    target_h = int(round(src_h * scale))

    cond_w = max(math.ceil(src_w / 16) * 16 * rscale_int, 512)
    cond_h = max(math.ceil(src_h / 16) * 16 * rscale_int, 512)
    lr_condition = lr_image.resize((cond_w, cond_h), Image.BICUBIC)
    lr_inp = img_preproc(lr_condition).unsqueeze(0).mul_(2.0).sub_(1.0).to(device, non_blocking=True)

    label_b = torch.zeros(1, dtype=torch.long, device=device)
    h = math.ceil(lr_inp.shape[2] / 16)
    w = math.ceil(lr_inp.shape[3] / 16)
    tile_size = folder_args.tile_size
    tile_overlap = folder_args.tile_overlap
    tile_weights = gaussian_weights(tile_size, tile_size, 1, device)
    grid_rows = grid_count(h, tile_size, tile_overlap)
    grid_cols = grid_count(w, tile_size, tile_overlap)

    recon_pred = []
    use_cuda_amp = str(device).startswith("cuda") or getattr(device, "type", "") == "cuda"
    start = time.time()

    for row in range(grid_rows):
        input_tiles = []
        for col in range(grid_cols):
            ofs_x = max(row * tile_size - tile_overlap * row, 0)
            ofs_y = max(col * tile_size - tile_overlap * col, 0)
            if row == grid_rows - 1:
                ofs_x = h - tile_size
            if col == grid_cols - 1:
                ofs_y = w - tile_size

            tile = lr_inp[
                :,
                :,
                ofs_x * 16 : (ofs_x + tile_size) * 16,
                ofs_y * 16 : (ofs_y + tile_size) * 16,
            ]
            input_tiles.append(tile)

        lr4var = torch.cat(input_tiles, dim=0) if len(input_tiles) > 1 else input_tiles[0]
        with torch.inference_mode():
            with torch.autocast("cuda", enabled=use_cuda_amp, dtype=torch.float16, cache_enabled=True):
                row_pred = var.autoregressive_infer_cfg(
                    B=grid_cols,
                    cfg=folder_args.cfg,
                    top_k=folder_args.top_k,
                    top_p=folder_args.top_p,
                    text_hidden=None,
                    lr_inp=lr4var,
                    negative_text=None,
                    label_B=label_b.repeat(grid_cols),
                    lr_inp_scale=None,
                    tile_flag=True,
                    more_smooth=False,
                )
        recon_pred.append(row_pred)

    preds = torch.zeros((1, 32, h, w), device=device)
    contributors = torch.zeros((1, 32, h, w), device=device)
    for row in range(grid_rows):
        for col in range(grid_cols):
            ofs_x = max(row * tile_size - tile_overlap * row, 0)
            ofs_y = max(col * tile_size - tile_overlap * col, 0)
            if row == grid_rows - 1:
                ofs_x = h - tile_size
            if col == grid_cols - 1:
                ofs_y = w - tile_size

            preds[:, :, ofs_x : ofs_x + tile_size, ofs_y : ofs_y + tile_size] += (
                recon_pred[row][col].unsqueeze(0) * tile_weights
            )
            contributors[:, :, ofs_x : ofs_x + tile_size, ofs_y : ofs_y + tile_size] += tile_weights

    preds /= contributors
    with torch.no_grad():
        recon = vae.fhat_to_img(preds).add_(1).mul_(0.5)
    image = numpy_to_pil(pt_to_numpy(recon))[0].resize((target_w, target_h), Image.BICUBIC)

    if not folder_args.no_color_fix:
        color_ref = lr_image.resize((target_w, target_h), Image.BICUBIC)
        image = adain_color_fix(image, color_ref)

    output_path.parent.mkdir(parents=True, exist_ok=True)
    save_kwargs = {}
    if output_path.suffix.lower() in {".jpg", ".jpeg"}:
        save_kwargs.update({"quality": 95})
    image.save(output_path, **save_kwargs)
    return time.time() - start, (src_w, src_h), (target_w, target_h), grid_rows, grid_cols


def main():
    folder_args = parse_folder_args()
    model_args = arg_util.init_dist_and_get_args()
    device = dist.get_device()
    input_dir = Path(folder_args.input_dir)
    output_dir = Path(folder_args.output_dir)
    extensions = [ext.strip() for ext in folder_args.extensions.split(",") if ext.strip()]

    if not input_dir.exists():
        raise FileNotFoundError(f"input_dir does not exist: {input_dir}")
    if not Path(model_args.vae_model_path).exists():
        raise FileNotFoundError(f"VQVAE checkpoint not found: {model_args.vae_model_path}")
    if not Path(model_args.var_test_path).exists():
        raise FileNotFoundError(f"VARSR checkpoint not found: {model_args.var_test_path}")

    image_paths = iter_images(input_dir, extensions, folder_args.limit)
    if not image_paths:
        raise RuntimeError(f"No images found in {input_dir} with extensions {extensions}")

    vae, var = build_models(model_args)
    print(f"Found {len(image_paths)} image(s). Writing to {output_dir}")

    for index, image_path in enumerate(image_paths, 1):
        rel = image_path.relative_to(input_dir)
        suffix = folder_args.save_ext if folder_args.save_ext else rel.suffix
        if suffix and not suffix.startswith("."):
            suffix = f".{suffix}"
        output_path = (output_dir / rel).with_suffix(suffix)
        if output_path.exists() and not folder_args.overwrite:
            print(f"[{index}/{len(image_paths)}] skip existing {output_path}")
            continue

        duration, src_size, dst_size, rows, cols = resolve_one(image_path, output_path, vae, var, folder_args, device)
        print(
            f"[{index}/{len(image_paths)}] {image_path} {src_size[0]}x{src_size[1]} -> "
            f"{dst_size[0]}x{dst_size[1]}, tiles={rows}x{cols}, {duration:.2f}s"
        )


if __name__ == "__main__":
    main()