Update RAR/1d-tokenizer/generate_rar_images.py

RAR/1d-tokenizer/generate_rar_images.py

@@ -2,98 +2,18 @@
 RAR IMAGE GENERATION + LIKELIHOOD EVALUATION
 ===========================================
 
-This script performs image generation and white-box likelihood analysis
-using a pretrained RAR (Reconstruction-Aware Autoregressive) generator
-with a MaskGit-VQ tokenizer.
+This script generates class-conditional images using a pretrained RAR
+(Reconstruction-Aware Autoregressive) generator with a MaskGit-VQ tokenizer,
+then computes token-level loss and probability on the generated images.
 
-The script supports:
-- Conditional image generation on ImageNet classes
-- Automatic configuration based on the selected RAR checkpoint
-- Token-level white-box access (tokens, logits, loss, probabilities)
-- Teacher-forced likelihood computation (NLL)
-- Saving images, CSV summaries, and NumPy artifacts
-
-------------------------------------------------
-REQUIREMENTS
-------------------------------------------------
-Before running, ensure the following files exist:
-
-1. RAR generator checkpoint (one of):
-   - checkpoints/rar_b.bin
-   - checkpoints/rar_l.bin
-   - checkpoints/rar_xl.bin
-   - checkpoints/rar_xxl.bin
-
-2. MaskGit-VQ tokenizer checkpoint:
-   - checkpoints/maskgit-vqgan-imagenet-f16-256.bin
-
-3. The repository must include:
-   - demo_util.py (patched to support return_tokens and teacher-forced logits)
-   - modeling/rar.py
-   - utils/train_utils.py
-
-------------------------------------------------
-BASIC USAGE
-------------------------------------------------
-Run the script directly:
+Key steps:
+1. Generate images with the RAR sampler (no logits returned during sampling).
+2. Re-tokenize the generated images using the tokenizer.
+3. Run the generator on those tokens to get logits and labels.
+4. Compute per-token NLL and mean token probability.
 
+Run from model_tracer/RAR/1d-tokenizer as -
     python generate_rar_images.py
-
-By default, the script:
-- Generates one image per class label
-- Uses the RAR-B checkpoint
-- Saves outputs to the folder: outputs_rar/
-
-------------------------------------------------
-CHANGING THE RAR MODEL SIZE
-------------------------------------------------
-To switch between RAR model variants, change ONLY this line:
-
-    RAR_CKPT = os.path.join(CHECKPOINT_DIR, "rar_b.bin")
-
-Supported options:
-- rar_b.bin   (smallest, fastest)
-- rar_l.bin
-- rar_xl.bin
-- rar_xxl.bin (largest, most expressive)
-
-The script automatically infers and applies the correct architecture
-(hidden size, depth, MLP size) from the checkpoint name.
-Manual configuration is NOT required and NOT recommended.
-
-------------------------------------------------
-CHANGING CLASS LABELS / NUMBER OF IMAGES
-------------------------------------------------
-Images are generated conditionally using ImageNet-1k class labels.
-
-Edit the following line:
-
-    class_labels = [980, 437, 22, 562]
-
-Rules:
-- Each entry produces one image
-- Duplicate labels generate multiple images from the same class
-- Total number of images = len(class_labels)
-
-Examples:
-- Single image:
-      class_labels = [980]
-
-- Multiple images from the same class:
-      class_labels = [980, 980, 980]
-
-- Mixed classes:
-      class_labels = [22, 437, 562]
-
-------------------------------------------------
-CONTROLLING RANDOMNESS
-------------------------------------------------
-Sampling randomness is controlled by the global seed:
-
-    seed = 0
-
-Changing the seed will generate different images for the same class labels.
-
 ------------------------------------------------
 WHAT THE SCRIPT OUTPUTS
 ------------------------------------------------
@@ -106,13 +26,8 @@ WHAT THE SCRIPT OUTPUTS
    Columns:
    - image_id
    - class_label
-   - sequence_nll
    - mean_token_nll
-   - min_token_nll
-   - max_token_nll
    - mean_token_prob
-   - min_token_prob
-   - max_token_prob
 
 3. NumPy archive (framework-agnostic):
    - outputs_rar/details.npz
@@ -125,31 +40,11 @@ WHAT THE SCRIPT OUTPUTS
    - outputs_rar/metadata.json
      Records model size, checkpoint, sampling parameters, and seed.
 
-------------------------------------------------
-ABOUT LIKELIHOOD AND TOKEN PROBABILITIES
-------------------------------------------------
-RAR does NOT expose logits during autoregressive sampling.
-
-Therefore, token-level loss and probabilities are computed via a
-separate teacher-forced evaluation step:
-
-1. Tokens are first generated using the official RAR sampling API.
-2. The generator is then re-run in teacher-forced mode on the generated
-   token sequence.
-3. Logits are aligned to exclude prefix/control tokens.
-4. Per-token negative log-likelihood (NLL) and probabilities are computed.
-
-This yields true model likelihoods, not sampling-time heuristics.
-
 ------------------------------------------------
 NOTES
 ------------------------------------------------
-- Sampling logic is unchanged from the official RAR implementation.
+- Token-level losses are computed on the generated images, not on ground-truth.
 - No retraining or weight modification is performed.
-- This script provides full white-box access suitable for auditing,
-  analysis, and research tasks.
-
-------------------------------------------------
 """
 
 import os
@@ -162,11 +57,31 @@ from PIL import Image
 import demo_util
 from utils.train_utils import create_pretrained_tokenizer
 
-# -------------------------------------------------
-# Configuration
-# -------------------------------------------------
+def update_weights(model, ckpt_path, delta=True):
+    state_dict = torch.load(ckpt_path, map_location="cpu", weights_only=False)
+    if "state_dict" in state_dict:
+        state_dict = state_dict["state_dict"]
+
+    if delta:
+        state_dict_to_apply = model.state_dict().copy()
+        for key in state_dict:
+            if key in state_dict_to_apply:
+                state_dict_to_apply[key] = state_dict_to_apply[key] + state_dict[key].to(
+                    state_dict_to_apply[key].device
+                )
+            else:
+                state_dict_to_apply[key] = state_dict[key]
+    else:
+        state_dict_to_apply = state_dict
+
+    missing, unexpected = model.load_state_dict(state_dict_to_apply, strict=False)
+    print(f"Missing: {missing}")
+    print(f"Unexpected: {unexpected}")
+
 CHECKPOINT_DIR = "checkpoints"
 OUT_DIR = "outputs_rar"
+enc_name = "orig_enc"
+ft_enc_path = "checkpoints/rar_ae_ft_delta.pth"
 os.makedirs(OUT_DIR, exist_ok=True)
 
 MASKGIT_CKPT = os.path.join(
@@ -187,9 +102,6 @@ np.random.seed(seed)
 class_labels = [980, 437, 22, 562]
 B = len(class_labels)
 
-# -------------------------------------------------
-# RAR checkpoint → architecture mapping
-# -------------------------------------------------
 RAR_CONFIGS = {
     "rar_b": {
         "hidden_size": 768,
@@ -231,35 +143,33 @@ rar_cfg = RAR_CONFIGS[ckpt_key]
 print(f"Using RAR checkpoint: {ckpt_name}")
 print(f"Auto-configured architecture: {ckpt_key}")
 
-# -------------------------------------------------
-# Load config and apply inferred architecture
-# -------------------------------------------------
 config = demo_util.get_config("configs/training/generator/rar.yaml")
-
 config.experiment.generator_checkpoint = RAR_CKPT
 config.model.vq_model.pretrained_tokenizer_weight = MASKGIT_CKPT
-
 config.model.generator.hidden_size = rar_cfg["hidden_size"]
 config.model.generator.num_hidden_layers = rar_cfg["num_hidden_layers"]
 config.model.generator.num_attention_heads = rar_cfg["num_attention_heads"]
 config.model.generator.intermediate_size = rar_cfg["intermediate_size"]
 
-# -------------------------------------------------
-# Build tokenizer and generator
-# -------------------------------------------------
 tokenizer = create_pretrained_tokenizer(config).to(device)
+
+match enc_name:
+    case "orig_enc":
+        pass
+    case "ft_enc":
+        update_weights(tokenizer.encoder, ft_enc_path)
+        print("Loaded finetuned tokenizer encoder (delta).")
+    case _:
+        raise ValueError(f"Unknown encoder name: {enc_name}")
 generator = demo_util.get_rar_generator(config).to(device)
 generator.eval()
 
 print("RAR tokenizer and generator loaded.")
 
-# -------------------------------------------------
-# Generate images + tokens (official sampling)
-# -------------------------------------------------
 labels = torch.tensor(class_labels, device=device)
 
 with torch.no_grad():
-    images, tokens = demo_util.sample_fn(
+    images = demo_util.sample_fn(
         generator=generator,
         tokenizer=tokenizer,
         labels=labels,
@@ -267,12 +177,8 @@ with torch.no_grad():
         guidance_scale_pow=0.0,
         randomize_temperature=1.0,
         device=device,
-        return_tokens=True,
     )
 
-# -------------------------------------------------
-# Save images
-# -------------------------------------------------
 for i, sample in enumerate(images):
     Image.fromarray(sample).save(
         f"{OUT_DIR}/rar_sample_{i}_class_{class_labels[i]}.png"
@@ -280,74 +186,49 @@ for i, sample in enumerate(images):
 
 print("Images saved.")
 
-# -------------------------------------------------
-# Teacher-forced likelihood computation (RAR)
-# -------------------------------------------------
+# Tokenize generated images for loss computation
 with torch.no_grad():
-    logits = demo_util.rar_teacher_forced_logits(
-        generator=generator,
-        tokens=tokens,
-        labels=labels,
+    tokens = tokenizer.encode(
+        torch.from_numpy(images).to(device).permute(0, 3, 1, 2).float() / 255.0
     )
 
-    # tokens: (B, T)
-    # logits: (B, L, V) where L >= T
+with torch.no_grad():
+    cond = generator.preprocess_condition(labels)
+    logits, labels_tf = generator(tokens, cond, return_labels=True)
 
-    targets = tokens[:, 1:]            # (B, T-1)
-    # Align logits to targets length from the END
-    logits = logits[:, -targets.shape[1]:, :]   # (B, T-1, V)
+    # logits: (B, N_tokens + 1, V), labels_tf: (B, N_tokens)
+    logits = logits[:, :-1]
 
     loss_per_token = torch.nn.functional.cross_entropy(
         logits.reshape(-1, logits.size(-1)),
-        targets.reshape(-1),
+        labels_tf.reshape(-1),
         reduction="none",
-    ).reshape(targets.shape)
-
+    ).reshape(labels_tf.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)
     mean_token_prob = token_probs.mean(dim=1)
-    min_token_prob = token_probs.min(dim=1).values
-    max_token_prob = token_probs.max(dim=1).values
 
-# -------------------------------------------------
-# Save CSV summary
-# -------------------------------------------------
 csv_path = os.path.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_prob",
-        "min_token_prob",
-        "max_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_prob[i].item(),
-            min_token_prob[i].item(),
-            max_token_prob[i].item(),
         ])
 
 print("CSV summary saved.")
 
-# -------------------------------------------------
-# Save detailed arrays (framework-agnostic)
-# -------------------------------------------------
 np.savez(
     os.path.join(OUT_DIR, "details.npz"),
     tokens=tokens.cpu().numpy(),
@@ -355,9 +236,6 @@ np.savez(
     token_probs=token_probs.cpu().numpy(),
 )
 
-# -------------------------------------------------
-# Save metadata
-# -------------------------------------------------
 with open(os.path.join(OUT_DIR, "metadata.json"), "w") as f:
     json.dump(
         {