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