infer_folder.py

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


def configure_cuda_device():
    parser = argparse.ArgumentParser(add_help=False)
    parser.add_argument("--gpu", type=int, default=None)
    early_args, _ = parser.parse_known_args()
    if early_args.gpu is not None:
        os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
        previous_visible_devices = os.environ.pop("CUDA_VISIBLE_DEVICES", None)
        if previous_visible_devices is not None:
            os.environ["VARSR_PREVIOUS_CUDA_VISIBLE_DEVICES"] = previous_visible_devices
        os.environ["VARSR_GPU_ID"] = str(early_args.gpu)


configure_cuda_device()

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, wavelet_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(
        "--gpu",
        type=int,
        default=None,
        help="CUDA GPU index to use directly; e.g. --gpu 2 selects cuda:2.",
    )
    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(
        "--color_fix",
        choices=("adain", "wavelet", "none"),
        default="adain",
        help="Output color/frequency correction. Wavelet uses LR low frequencies and VARSR high frequencies.",
    )
    parser.add_argument(
        "--wavelet_high_freq_weight",
        type=float,
        default=1.0,
        help="VARSR high-frequency weight used by --color_fix wavelet.",
    )
    parser.add_argument(
        "--wavelet_levels",
        type=int,
        default=5,
        help="Number of decomposition levels used by --color_fix wavelet.",
    )
    parser.add_argument(
        "--no_color_fix",
        action="store_true",
        help="Deprecated alias for --color_fix none.",
    )
    folder_args, remaining = parser.parse_known_args()
    if folder_args.no_color_fix:
        if folder_args.color_fix == "wavelet":
            parser.error("--no_color_fix cannot be combined with --color_fix wavelet")
        folder_args.color_fix = "none"
    if folder_args.wavelet_high_freq_weight < 0:
        parser.error("--wavelet_high_freq_weight must be non-negative")
    if folder_args.wavelet_levels <= 0:
        parser.error("--wavelet_levels must be positive")
    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 folder_args.color_fix != "none":
        color_ref = lr_image.resize((target_w, target_h), Image.BICUBIC)
        if folder_args.color_fix == "adain":
            image = adain_color_fix(image, color_ref)
        else:
            image = wavelet_color_fix(
                image,
                color_ref,
                levels=folder_args.wavelet_levels,
                high_freq_weight=folder_args.wavelet_high_freq_weight,
            )

    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()
    if folder_args.gpu is not None and not torch.cuda.is_available():
        raise RuntimeError(
            f"Requested GPU {folder_args.gpu}, but CUDA is unavailable"
        )
    if folder_args.gpu is not None and not 0 <= folder_args.gpu < torch.cuda.device_count():
        raise RuntimeError(
            f"Requested GPU {folder_args.gpu}, but PyTorch sees CUDA indices "
            f"0..{torch.cuda.device_count() - 1}"
        )
    model_args = arg_util.init_dist_and_get_args()
    device = dist.get_device()
    print(
        "CUDA selection: "
        f"requested_gpu={folder_args.gpu}, "
        f"CUDA_DEVICE_ORDER={os.environ.get('CUDA_DEVICE_ORDER')}, "
        f"CUDA_VISIBLE_DEVICES={os.environ.get('CUDA_VISIBLE_DEVICES')}, "
        f"previous_CUDA_VISIBLE_DEVICES={os.environ.get('VARSR_PREVIOUS_CUDA_VISIBLE_DEVICES')}, "
        f"VARSR_GPU_ID={os.environ.get('VARSR_GPU_ID')}, "
        f"logical_device={device}, "
        f"device_name={torch.cuda.get_device_name(device) if torch.cuda.is_available() else 'CPU'}, "
        f"pid={os.getpid()}"
    )
    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}")
    print(
        f"Post-processing: color_fix={folder_args.color_fix}, "
        f"wavelet_levels={folder_args.wavelet_levels}, "
        f"wavelet_high_freq_weight={folder_args.wavelet_high_freq_weight}"
    )

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