Update VAR/generate_var_images.py

VAR/generate_var_images.py

@@ -1,99 +1,19 @@
 """
 VAR White-Box Image Generation and Likelihood Analysis
-=====================================================
-
 USAGE
 -----
-This script performs three things:
-1. Generates class-conditional images using a pretrained VAR + VQ-VAE model.
-2. Extracts the full discrete VQ token sequence used to generate each image.
-3. Computes teacher-forced negative log-likelihood (NLL) and token probabilities,
-   exposing white-box model confidence signals.
+This script generates class-conditional images using a pretrained VAR + VQ-VAE model
+and computes token-level cross-entropy and token probabilities.
+
 
 Run:
     python generate_var_images.py
 
 Outputs (saved in ./outputs/):
 - sample_<id>_class_<label>.png   : generated images
-- summary.csv                     : per-image likelihood and probability statistics
-- details.npz                     : per-token loss and probabilities (NumPy arrays)
+- summary.csv                     : per-image loss/probability statistics
+- details.npz                     : per-token losses/probabilities and tokens (NumPy arrays)
 - metadata.json                   : run configuration
-
-All likelihoods and probabilities are computed using teacher forcing and are
-NOT affected by top-k, top-p, or classifier-free guidance truncation.
-
-
-CHANGING MODEL DEPTH
---------------------
-The model depth MUST match the checkpoint being loaded.
-
-To change depth:
-1. Set MODEL_DEPTH below to one of: {16, 20, 24, 30}
-2. Ensure the corresponding checkpoint exists:
-       checkpoints/var_d<MODEL_DEPTH>.pth
-
-Example:
-    MODEL_DEPTH = 20
-    -> loads checkpoints/var_d20.pth
-
-Using a mismatched depth will cause incorrect loading or silent errors.
-
-CHANGING CLASSES AND NUMBER OF IMAGES
-------------------------------------
-Images are generated conditionally based on ImageNet class labels.
-
-To change which images are generated, edit:
-    class_labels = [980, 437, 22, 562]
-
-Each entry corresponds to one generated image. Duplicate labels will generate
-multiple images from the same class.
-
-Examples:
-- Generate one image from a single class:
-      class_labels = [980]
-
-- Generate multiple images from the same class:
-      class_labels = [980, 980, 980]
-
-- Generate images from multiple classes:
-      class_labels = [22, 437, 562]
-
-The total number of generated images equals:
-      B = len(class_labels)
-
-Randomness is controlled by the global seed. To generate different images for
-the same class labels, change the `seed` value at the top of the file.
-
-
-ABOUT LOSS AND TOKEN PROBABILITIES (IMPORTANT)
-----------------------------------------------
-For each generated image, we compute per-token negative log-likelihood (NLL):
-
-    NLL_t = -log p(x_t | x_<t)
-
-From this, token probabilities are derived as:
-
-    p_t = exp(-NLL_t)
-
-We report BOTH:
-- mean_token_nll   = mean_t(NLL_t)
-- mean_token_prob  = mean_t(p_t)
-
-Interpretation:
-- mean_token_nll     measures average surprise in log-space (theoretically clean).
-- mean_token_prob    measures average confidence in probability-space (intuitive).
-- Differences between them capture variance in token difficulty across the image.
-
-WHITE-BOX ACCESS GUARANTEE
---------------------------
-This script provides full white-box access to the model by exposing:
-- discrete VQ tokens
-- per-token NLL
-- per-token probabilities
-- aggregate confidence statistics
-
-All outputs are saved in framework-agnostic formats (PNG, CSV, NPZ, JSON),
-allowing participants to analyze model behavior without modifying the model.
 """
 
 import os
@@ -103,11 +23,9 @@ import json
 import csv
 import numpy as np
 import torch
+from torch.nn import functional as F
 from PIL import Image
 
-# -------------------------------------------------
-# Reproducibility and performance
-# -------------------------------------------------
 seed = 0
 torch.manual_seed(seed)
 random.seed(seed)
@@ -119,30 +37,30 @@ torch.backends.cuda.matmul.allow_tf32 = True
 torch.backends.cudnn.allow_tf32 = True
 torch.set_float32_matmul_precision("high")
 
-# Disable default init (speed)
 setattr(torch.nn.Linear, "reset_parameters", lambda self: None)
 setattr(torch.nn.LayerNorm, "reset_parameters", lambda self: None)
 
-# -------------------------------------------------
-# Imports from VAR repo
-# -------------------------------------------------
 from models import build_vae_var
 
-# -------------------------------------------------
-# Configuration
-# -------------------------------------------------
 MODEL_DEPTH = 16  # must match checkpoint
 CHECKPOINT_DIR = "checkpoints"
 OUT_DIR = "outputs"
+ENC_NAME = "orig_enc" 
+FT_VAE_CKPT = "checkpoints/var_ae_ft.pth"
 os.makedirs(OUT_DIR, exist_ok=True)
 
-VAE_CKPT = osp.join(CHECKPOINT_DIR, "vae_ch160v4096z32.pth")
+if ENC_NAME == "orig_enc":
+    VAE_CKPT = osp.join(CHECKPOINT_DIR, "vae_ch160v4096z32.pth")
+elif ENC_NAME == "ft_enc":
+    VAE_CKPT = FT_VAE_CKPT
+else:
+    raise ValueError(f"Unknown encoder name: {ENC_NAME}")
 VAR_CKPT = osp.join(CHECKPOINT_DIR, f"var_d{MODEL_DEPTH}.pth")
 
 device = "cuda" if torch.cuda.is_available() else "cpu"
 
 # ImageNet class labels to generate
-class_labels = [12, 12, 14]  # Example: 'golden retriever'
+class_labels = [120, 120, 140]  # Example: 'golden retriever'
 
 # Sampling parameters
 cfg_scale = 3.0
@@ -150,9 +68,6 @@ top_k = 900
 top_p = 0.95
 more_smooth = False
 
-# -------------------------------------------------
-# Build models
-# -------------------------------------------------
 patch_nums = (1, 2, 3, 4, 5, 6, 8, 10, 13, 16)
 
 vae, var = build_vae_var(
@@ -179,15 +94,15 @@ for p in var.parameters():
 
 print("Models loaded.")
 
-# -------------------------------------------------
-# Generate images (official API)
-# -------------------------------------------------
+def get_token_list(images):
+    return vae.img_to_idxBl(images, v_patch_nums=patch_nums)
+
 label_B = torch.tensor(class_labels, device=device)
 B = len(class_labels)
 
 with torch.inference_mode():
     with torch.autocast("cuda", enabled=(device == "cuda"), dtype=torch.float16):
-        images, tokens = var.autoregressive_infer_cfg(
+        images = var.autoregressive_infer_cfg(
             B=B,
             label_B=label_B,
             cfg=cfg_scale,
@@ -195,12 +110,8 @@ with torch.inference_mode():
             top_p=top_p,
             g_seed=seed,
             more_smooth=more_smooth,
-            return_tokens=True,   # <<< requires small repo patch (see note below)
         )
 
-# -------------------------------------------------
-# Save standalone images
-# -------------------------------------------------
 for i, img in enumerate(images):
     img = (
         img.permute(1, 2, 0)
@@ -216,87 +127,55 @@ for i, img in enumerate(images):
 
 print("Images saved.")
 
-# -------------------------------------------------
-# Teacher-forced likelihood computation
-# -------------------------------------------------
 with torch.inference_mode():
-    # Convert tokens -> VQ embeddings
-    token_embeddings = var.vae_quant_proxy[0].embedding(tokens)  # (B, T, Cvae)
+    # VQ-VAE expects float inputs in [-1, 1]
+    images_for_loss = images.float().mul(2.0).sub(1.0)
 
-    # Remove first-level tokens (teacher forcing protocol)
-    x_BLCv_wo_first_l = token_embeddings[:, var.first_l:, :]     # (B, L-first_l, Cvae)
+    token_list = get_token_list(images_for_loss)
+    gt_BL = torch.cat(token_list, dim=1)
+    var_input = vae.quantize.idxBl_to_var_input(token_list)
+    logits = var(label_B, var_input)
 
-    # Forward pass (correct argument order)
-    logits = var(label_B, x_BLCv_wo_first_l)                     # (B, L, V)
-
-    # Targets are next-token indices
-    targets = tokens[:, 1:]                                      # (B, L)
-
-    # Align logits with targets
-    logits = logits[:, :-1, :]                                   # (B, L-1, V)
-    targets = targets[:, -logits.shape[1]:]                      # safety align
-
-    # Cross-entropy per token
-    loss_per_token = torch.nn.functional.cross_entropy(
-        logits.reshape(-1, logits.size(-1)),
-        targets.reshape(-1),
+    loss_per_token_ce = F.cross_entropy(
+        logits.permute(0, 2, 1),
+        gt_BL,
         reduction="none",
-    ).reshape(targets.shape)
+    )
 
-    sequence_nll = loss_per_token.sum(dim=1)
-    mean_token_nll = loss_per_token.mean(dim=1)
+    token_probs = torch.exp(-loss_per_token_ce)
 
-    # Token probabilities from NLL
-    token_probs = torch.exp(-loss_per_token)
+    mean_token_ce = loss_per_token_ce.mean(dim=1)
     mean_token_prob = token_probs.mean(dim=1)
-    min_token_prob = token_probs.min(dim=1).values
 
-
-# -------------------------------------------------
-# Save CSV summary (human-readable)
-# -------------------------------------------------
 csv_path = osp.join(OUT_DIR, "summary.csv")
 with open(csv_path, "w", newline="") as f:
     writer = csv.writer(f)
     writer.writerow([
         "image_id",
         "class_label",
-        "sequence_nll",
-        "mean_token_nll",
-        "min_token_nll",
-        "max_token_nll",
+        "mean_token_ce",
         "mean_token_prob",
-        "min_token_prob",
     ])
 
     for i in range(B):
         writer.writerow([
             i,
             class_labels[i],
-            sequence_nll[i].item(),
-            mean_token_nll[i].item(),
-            loss_per_token[i].min().item(),
-            loss_per_token[i].max().item(),
+            mean_token_ce[i].item(),
             mean_token_prob[i].item(),
-            min_token_prob[i].item(),
         ])
 
 print("CSV summary saved.")
 
-# -------------------------------------------------
-# Save detailed arrays (NumPy, framework-agnostic)
-# -------------------------------------------------
+
 np.savez(
     osp.join(OUT_DIR, "details.npz"),
-    tokens=tokens.cpu().numpy(),
-    loss_per_token=loss_per_token.cpu().numpy(),
+    tokens=gt_BL.cpu().numpy(),
+    loss_per_token_ce=loss_per_token_ce.cpu().numpy(),
     token_probs=token_probs.cpu().numpy(),
-
 )
 
-# -------------------------------------------------
-# Save metadata
-# -------------------------------------------------
+
 with open(osp.join(OUT_DIR, "metadata.json"), "w") as f:
     json.dump(
         {