Upload 2 files

RAR.py

@@ -0,0 +1,250 @@
+import os
+import sys
+import subprocess
+import shutil
+import venv
+import json
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parent
+VENV_DIR = ROOT / ".rar_env"
+REPO_DIR = ROOT / "1d-tokenizer"
+OUT_DIR = ROOT / "outputs_rar"
+WEIGHT_DIR = ROOT / "weights"
+
+# Defaults for direct run (no terminal args needed)
+DEFAULT_CLASS_ID = 207
+DEFAULT_CLASS_IDS = [1,3,5,9]  # e.g., [207, 282, 404] to generate multiple by default
+DEFAULT_NUM_IMAGES = 1
+DEFAULT_RAR_SIZE = "rar_xl"  # one of: rar_b, rar_l, rar_xl, rar_xxl
+
+
+def run(cmd, cwd=None, env=None, check=True, quiet=False):
+    # Nicely print the command without dumping large inline code blobs
+    display = cmd[:]
+    if "-c" in display:
+        try:
+            i = display.index("-c")
+            if i + 1 < len(display):
+                display[i + 1] = "<inline>"
+        except ValueError:
+            pass
+    print(f"[run] {' '.join(display)}")
+    stdout = subprocess.DEVNULL if quiet else None
+    stderr = subprocess.DEVNULL if quiet else None
+    return subprocess.run(cmd, cwd=cwd, env=env, check=check, stdout=stdout, stderr=stderr)
+
+
+def ensure_venv() -> Path:
+    """Create a local venv if missing and return its python path."""
+    if not VENV_DIR.exists():
+        print(f"[setup] Creating venv at {VENV_DIR}")
+        builder = venv.EnvBuilder(with_pip=True)
+        builder.create(VENV_DIR)
+    # Determine python executable inside venv (Windows/Linux)
+    if os.name == 'nt':
+        py = VENV_DIR / "Scripts" / "python.exe"
+    else:
+        py = VENV_DIR / "bin" / "python"
+    return py
+
+
+def in_venv() -> bool:
+    return sys.prefix != getattr(sys, "base_prefix", sys.prefix)
+
+
+def install_requirements(venv_python: Path):
+    # Upgrade pip tooling first
+    run([str(venv_python), "-m", "pip", "install", "--upgrade", "pip", "setuptools", "wheel", "-q"], quiet=True)
+    # Clone repo first so we can install its requirements
+    if not REPO_DIR.exists():
+        print(f"[setup] Cloning bytedance/1d-tokenizer into {REPO_DIR}")
+        run(["git", "clone", "https://github.com/bytedance/1d-tokenizer", str(REPO_DIR)])
+    else:
+        print(f"[setup] Repo exists, pulling latest...")
+        run(["git", "pull", "--ff-only"], cwd=str(REPO_DIR))
+
+    # Install repo requirements
+    req = REPO_DIR / "requirements.txt"
+    deps_marker = VENV_DIR / ".deps_installed"
+    if req.exists():
+        if not deps_marker.exists():
+            print("[setup] Installing repo requirements (first time)")
+            run([str(venv_python), "-m", "pip", "install", "-r", str(req), "-q"], quiet=True)
+            # Ensure diffusers only if needed
+            cp = run([str(venv_python), "-c", "import diffusers"], check=False, quiet=True)
+            if cp.returncode != 0:
+                run([str(venv_python), "-m", "pip", "install", "diffusers<0.32", "-q"], quiet=True)
+            deps_marker.write_text("ok")
+        else:
+            print("[setup] Requirements already installed; skipping")
+    else:
+        print("[warn] requirements.txt not found; installing minimal deps")
+        run([str(venv_python), "-m", "pip", "install",
+             "torch>=2.0.0", "torchvision", "omegaconf", "transformers", "timm",
+             "open_clip_torch", "einops", "scipy", "pillow", "accelerate",
+             "gdown", "huggingface-hub", "wandb", "torch-fidelity", "torchinfo", "webdataset", "-q"], quiet=True)
+
+
+def reexec_in_venv(venv_python: Path):
+    # Re-exec this script inside the venv
+    env = os.environ.copy()
+    env["RAR_BOOTSTRAPPED"] = "1"
+    cmd = [str(venv_python), str(Path(__file__).resolve())] + sys.argv[1:]
+    run(cmd, env=env)
+    sys.exit(0)
+
+
+def hf_download(venv_python: Path, repo_id: str, filename: str, local_dir: Path) -> Path:
+    local_dir.mkdir(parents=True, exist_ok=True)
+    code = f"""
+import sys
+from pathlib import Path
+from huggingface_hub import hf_hub_download
+path = hf_hub_download(repo_id={repo_id!r}, filename={filename!r}, local_dir={str(local_dir)!r})
+print(path)
+"""
+    cp = subprocess.run([str(venv_python), "-c", code], stdout=subprocess.PIPE, text=True, check=True)
+    p = Path(cp.stdout.strip())
+    if not p.exists():
+        raise RuntimeError(f"Download failed for {repo_id}/{filename}")
+    return p
+
+
+def generate_imagenet_class(venv_python: Path, class_id: int, rar_size: str = "rar_xl", num_images: int = 1):
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+    WEIGHT_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Ensure weights are present
+    print("[weights] Downloading tokenizer and RAR weights if missing...")
+    tok_path = hf_download(venv_python, "fun-research/TiTok", "maskgit-vqgan-imagenet-f16-256.bin", WEIGHT_DIR)
+    rar_bin = f"{rar_size}.bin"
+    rar_path = hf_download(venv_python, "yucornetto/RAR", rar_bin, WEIGHT_DIR)
+
+    # Execute generation inline inside the venv
+    code = f"""
+import sys
+from pathlib import Path
+import traceback
+
+REPO_DIR = Path({str(REPO_DIR)!r})
+WEIGHT_DIR = Path({str(WEIGHT_DIR)!r})
+OUT_DIR = Path({str(OUT_DIR)!r})
+
+try:
+    import torch
+    from PIL import Image
+    if str(REPO_DIR) not in sys.path:
+        sys.path.insert(0, str(REPO_DIR))
+    import demo_util
+    from modeling.titok import PretrainedTokenizer
+    from modeling.rar import RAR
+
+    cfg_map = {{
+        
+        'rar_xl': dict(hidden_size=1280, layers=32, heads=16, mlp=5120),
+    }}
+    rar_size = {rar_size!r}
+    assert rar_size in cfg_map, f"Unsupported rar size: {{rar_size}}"
+
+    config = demo_util.get_config(str(REPO_DIR / 'configs' / 'training' / 'generator' / 'rar.yaml'))
+    config.experiment.generator_checkpoint = str(WEIGHT_DIR / f"{{rar_size}}.bin")
+    config.model.generator.hidden_size = cfg_map[rar_size]['hidden_size']
+    config.model.generator.num_hidden_layers = cfg_map[rar_size]['layers']
+    config.model.generator.num_attention_heads = cfg_map[rar_size]['heads']
+    config.model.generator.intermediate_size = cfg_map[rar_size]['mlp']
+    config.model.vq_model.pretrained_tokenizer_weight = str(WEIGHT_DIR / 'maskgit-vqgan-imagenet-f16-256.bin')
+
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+    tokenizer = PretrainedTokenizer(config.model.vq_model.pretrained_tokenizer_weight)
+    generator = RAR(config)
+    generator.load_state_dict(torch.load(config.experiment.generator_checkpoint, map_location='cpu'))
+    generator.eval(); generator.requires_grad_(False); generator.set_random_ratio(0)
+    tokenizer.to(device)
+    generator.to(device)
+
+    cls_id = int({class_id})
+    num_images = int({num_images})
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+    for i in range(num_images):
+        imgs = demo_util.sample_fn(
+            generator=generator,
+            tokenizer=tokenizer,
+            labels=[cls_id],
+            randomize_temperature=1.02,
+            guidance_scale=6.9,
+            guidance_scale_pow=1.5,
+            device=device,
+        )
+        Image.fromarray(imgs[0]).save(OUT_DIR / f'rar_{{rar_size}}_cls{{cls_id}}_{{i}}.png')
+    print('DONE')
+except Exception:
+    print('[ERROR] Generation failed:')
+    traceback.print_exc()
+    raise
+"""
+    run([str(venv_python), "-c", code])
+
+
+def parse_args():
+    import argparse
+    p = argparse.ArgumentParser(description="RAR-XL one-shot setup and sampling")
+    p.add_argument("--class_id", type=int, default=DEFAULT_CLASS_ID, help="ImageNet-1K class id [0..999]")
+  
+    p.add_argument("--rar_size", type=str, default=DEFAULT_RAR_SIZE, help="RAR model variant (fixed to rar_xl)")
+    p.add_argument("--num_images", type=int, default=DEFAULT_NUM_IMAGES, help="Number of images to generate")
+    p.add_argument("--class_ids", type=int, nargs='+', help="Generate for multiple class ids [0..999]")
+    args = p.parse_args()
+    # Enforce XL regardless of user input
+    args.rar_size = "rar_xl"
+
+    # Optional: supply class IDs via env var or classes.txt without terminal args
+    if args.class_ids is None:
+        env_cls = os.environ.get("RAR_CLASS_IDS")
+        if env_cls:
+            try:
+                args.class_ids = [int(x.strip()) for x in env_cls.split(',') if x.strip()]
+            except Exception:
+                args.class_ids = None
+    if args.class_ids is None:
+        classes_file = ROOT / "classes.txt"
+        if classes_file.exists():
+            try:
+                raw = classes_file.read_text()
+                args.class_ids = [int(x) for x in raw.replace('\n', ' ').split() if x.strip()]
+            except Exception:
+                args.class_ids = None
+    if args.class_ids is None and DEFAULT_CLASS_IDS:
+        args.class_ids = list(DEFAULT_CLASS_IDS)
+
+    return args
+
+
+def main():
+    args = parse_args()
+
+    # Phase 1: ensure venv and requirements
+    if not in_venv() and os.environ.get("RAR_BOOTSTRAPPED") != "1":
+        vpy = ensure_venv()
+        install_requirements(vpy)
+        reexec_in_venv(vpy)
+        return
+
+    # Phase 2: already in venv — clone if needed (done in install), then generate
+    # Ensure repo exists (in case venv already existed but repo missing)
+    if not REPO_DIR.exists():
+        run(["git", "clone", "https://github.com/bytedance/1d-tokenizer", str(REPO_DIR)])
+
+    vpy = Path(sys.executable)
+    if args.class_ids:
+        for cid in args.class_ids:
+            generate_imagenet_class(vpy, class_id=int(cid), rar_size=args.rar_size, num_images=args.num_images)
+    else:
+        generate_imagenet_class(vpy, class_id=args.class_id, rar_size=args.rar_size, num_images=args.num_images)
+    print(f"[done] Images saved to {OUT_DIR}")
+
+
+if __name__ == "__main__":
+    main()

VAR.py

@@ -0,0 +1,160 @@
+import os
+import subprocess
+import sys
+import urllib.request
+import venv
+import textwrap
+
+ENV_DIR = "var_env"
+
+# ==============================
+# 1. Create a clean venv
+# ==============================
+if not os.path.exists(ENV_DIR):
+    print(f">>> Creating virtual environment: {ENV_DIR}")
+    venv.EnvBuilder(with_pip=True).create(ENV_DIR)
+else:
+    print(f">>> Using existing virtual environment: {ENV_DIR}")
+
+def find_venv_python(env_dir):
+    # Windows
+    win_dir = os.path.join(env_dir, "Scripts")
+    if os.path.exists(win_dir):
+        for name in ["python.exe", "python3.exe"]:
+            candidate = os.path.join(win_dir, name)
+            if os.path.exists(candidate):
+                return os.path.abspath(candidate)
+    # Unix
+    unix_dir = os.path.join(env_dir, "bin")
+    if os.path.exists(unix_dir):
+        for name in ["python3", "python"]:
+            candidate = os.path.join(unix_dir, name)
+            if os.path.exists(candidate):
+                return os.path.abspath(candidate)
+    return sys.executable
+
+VENV_PY = find_venv_python(ENV_DIR)
+print(">>> Using venv Python at:", VENV_PY)
+
+# ==============================
+# 2. Clone VAR repo if missing
+# ==============================
+if not os.path.exists("VAR"):
+    print(">>> Cloning VAR repo...")
+    subprocess.run(["git", "clone", "https://github.com/FoundationVision/VAR.git"], check=True)
+
+os.chdir("VAR")
+
+# ==============================
+# 3. Download checkpoints
+# ==============================
+os.makedirs("checkpoints/var", exist_ok=True)
+os.makedirs("checkpoints/vae", exist_ok=True)
+
+def download(url, out_path):
+    if not os.path.exists(out_path):
+        print(f">>> Downloading {out_path}")
+        urllib.request.urlretrieve(url, out_path)
+    else:
+        print(f">>> Already exists: {out_path}")
+
+download("https://huggingface.co/FoundationVision/var/resolve/main/var_d16.pth",
+         "checkpoints/var/var_d16.pth")
+download("https://huggingface.co/FoundationVision/var/resolve/main/vae_ch160v4096z32.pth",
+         "checkpoints/vae/vae_ch160v4096z32.pth")
+
+# ==============================
+# 4. Install dependencies
+# ==============================
+print(">>> Installing dependencies in venv")
+subprocess.run([VENV_PY, "-m", "pip", "install", "--upgrade", "pip"], check=True)
+subprocess.run([VENV_PY, "-m", "pip", "install",
+                "torch>=2.0.0", "torchvision", "torchaudio",
+                "--index-url", "https://download.pytorch.org/whl/cu121"], check=True)
+
+# clean torch pin
+req_file = "requirements.txt"
+if os.path.exists(req_file):
+    with open(req_file, "r") as f:
+        lines = f.readlines()
+    with open(req_file, "w") as f:
+        for line in lines:
+            if line.strip().startswith("torch"):
+                continue
+            f.write(line)
+
+subprocess.run([VENV_PY, "-m", "pip", "install", "-r", "requirements.txt"], check=True)
+
+# ==============================
+# 5. Write sample.py (generation code)
+# ==============================
+sample_code = textwrap.dedent("""
+    import argparse, os, torch, random, numpy as np
+    from PIL import Image
+    from models import build_vae_var
+
+    def main():
+        parser = argparse.ArgumentParser()
+        parser.add_argument("--ckpt", type=str, required=True)
+        parser.add_argument("--vae", type=str, required=True)
+        parser.add_argument("--depth", type=int, default=16)
+        parser.add_argument("--classes", type=int, nargs="+", default=[207,483,701,970])
+        parser.add_argument("--cfg", type=float, default=4.0)
+        parser.add_argument("--output", type=str, default="outputs/var_class_samples")
+        args = parser.parse_args()
+
+        seed = 0
+        torch.manual_seed(seed); random.seed(seed); np.random.seed(seed)
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        patch_nums = (1,2,3,4,5,6,8,10,13,16)
+
+        vae, var = build_vae_var(V=4096, Cvae=32, ch=160, share_quant_resi=4,
+                                 device=device, patch_nums=patch_nums,
+                                 num_classes=1000, depth=args.depth, shared_aln=False)
+        vae.load_state_dict(torch.load(args.vae, map_location="cpu"))
+        var.load_state_dict(torch.load(args.ckpt, map_location="cpu"))
+        vae.eval(); var.eval()
+        for p in vae.parameters(): p.requires_grad_(False)
+        for p in var.parameters(): p.requires_grad_(False)
+
+        labels = torch.tensor(args.classes, device=device, dtype=torch.long)
+
+        with torch.inference_mode():
+            with torch.autocast("cuda", enabled=True, dtype=torch.float16):
+                imgs = var.autoregressive_infer_cfg(
+                    B=len(labels), label_B=labels,
+                    cfg=args.cfg, top_k=900, top_p=0.95,
+                    g_seed=seed, more_smooth=False
+                )
+
+        os.makedirs(args.output, exist_ok=True)
+        for i, img in enumerate(imgs):
+            arr = img.permute(1,2,0).mul(255).clamp(0,255).byte().cpu().numpy()
+            out_path = os.path.join(args.output, f"class_{args.classes[i]}_{i}.png")
+            Image.fromarray(arr).resize((256,256), Image.LANCZOS).save(out_path)
+            print(">>> Saved", out_path)
+
+    if __name__ == "__main__":
+        main()
+""")
+
+with open("sample.py", "w") as f:
+    f.write(sample_code)
+
+# ==============================
+# 6. Run sample generation
+# ==============================
+print(">>> Running class-conditional generation in venv")
+os.makedirs("outputs/var_class_samples", exist_ok=True)
+
+subprocess.run([VENV_PY, "sample.py",
+                "--ckpt", "checkpoints/var/var_d16.pth",
+                "--vae", "checkpoints/vae/vae_ch160v4096z32.pth",
+                "--depth", "16",
+                "--classes", "207", "483", "701", "970",
+                "--output", "outputs/var_class_samples"], check=True)
+
+print(">>> Done! Check images in VAR/outputs/var_class_samples/")