Add files using upload-large-folder tool

.gitattributes

@@ -58,3 +58,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/SmolLM/512x512.jsonl filter=lfs diff=lfs merge=lfs -text
+data/Qwen3/1.7b_512x512.jsonl filter=lfs diff=lfs merge=lfs -text
+data/Qwen3/4b_1024x128.jsonl filter=lfs diff=lfs merge=lfs -text
+data/Maze/variance/5000.jsonl filter=lfs diff=lfs merge=lfs -text
+data/Maze/variance/0000.jsonl filter=lfs diff=lfs merge=lfs -text
+data/Maze/variance/8000.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,19 @@
+---
+pretty_name: Variance Analysis
+---
+
+# Variance Analysis
+
+This repository contains the data, scripts, and generated figures used for
+variance analysis experiments.
+
+## Contents
+
+- `data/SmolLM`: SmolLM GSM8K rollout data.
+- `data/Qwen3`: Qwen3 math rollout data, including 1.7B `512 x 512` and
+  4B `1024 x 128` samples.
+- `data/Maze/variance`: Maze rollout data for variance analysis.
+- `outputs`: generated JSON summaries and figures.
+- `*.py` and `run_*.sh`: analysis, plotting, and Slurm launch scripts.
+
+See `data/README.md` for additional data details and source model links.

damans_code.py

@@ -0,0 +1,173 @@
+import os
+import json
+import torch
+import matplotlib.pyplot as plt
+import torchvision.models as models
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+
+from verl.cifar10_experiments.sampling_based_rl_objective_experiments import HFImageNet, calculate_loss
+
+from datasets import load_dataset
+from torchvision import transforms
+
+def gradient_snr(gradients: torch.Tensor, eps: float = 1e-8) -> torch.Tensor:
+    """
+    Compute the gradient SNR given a set of per-sample gradients.
+
+    Args:
+        gradients: (N, D) tensor of N gradient vectors, each of dimension D.
+        eps: small constant for numerical stability.
+
+    Returns:
+        snr: scalar tensor, ||mean||^2 / ||var||.
+    """
+    # gradients: (N, D)
+    mu  = gradients.mean(dim=0)                # (D,)
+    var = gradients.var(dim=0, unbiased=False)  # (D,)
+    mean_sq_norm = mu.pow(2).sum()             # ||mu||^2
+    var_sum      = var.sum()                   # ||var||
+    snr = mean_sq_norm / (var_sum + eps)
+    return snr, mean_sq_norm, var_sum
+
+
+CHECKPOINT_PATH = "/data/imagenet256_checkpoints/cross_entropy_1024/checkpoint_latest_final.pth"
+BATCH_SIZE = 1024
+BATCH_CACHE_PATH = f"batch_{BATCH_SIZE}.pt"
+S = 64    # number of gradient samples used to estimate SNR
+
+ADVANTAGE_TYPES  = ["grpo", "reinforce_with_baseline", "reinforce_with_p_normalization",]
+# ADVANTAGE_TYPES  = ["grpo"]
+# ROLLOUT_COUNTS   = [4, 8, 16, 32, 64]
+# ROLLOUT_COUNTS   = [64, 128, 256]
+# ROLLOUT_COUNTS = [4, 16, 64, 256, 1024, 4096]
+ROLLOUT_COUNTS = [2**i for i in range(2, 22, 2)]
+print(ROLLOUT_COUNTS)
+# ROLLOUT_COUNTS = [2**14, 2**16, 2**18, 2**20]
+
+# ROLLOUT_COUNTS = [2**22, 2**24, 2**26]
+
+SNR_STATS_PATH   = "snr_stats_large.json"
+MINI_BATCH_SIZE  = 512  # number of images per minibatch to avoid OOM
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Load model
+model = models.resnet50(num_classes=1000)
+checkpoint = torch.load(CHECKPOINT_PATH, map_location="cpu")
+model.load_state_dict(checkpoint["model_state"])
+model = model.to(device)
+model.eval()
+
+# Load one batch of BATCH_SIZE images from imagenet (cached)
+if os.path.exists(BATCH_CACHE_PATH):
+    print(f"Loading cached batch from {BATCH_CACHE_PATH}")
+    batch = torch.load(BATCH_CACHE_PATH)
+else:
+    print("Cache not found, loading dataset...")
+    mean = (0.485, 0.456, 0.406)
+    std  = (0.229, 0.224, 0.225)
+
+    test_transform = transforms.Compose([
+        transforms.Resize(256),
+        transforms.CenterCrop(224),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=mean, std=std),
+    ])
+
+    hf_ds = load_dataset("benjamin-paine/imagenet-1k-256x256")
+    dataset = HFImageNet(split="validation", transform=test_transform, hf_ds=hf_ds)
+    loader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=4, pin_memory=True)
+
+    batch = next(iter(loader))
+    torch.save(batch, BATCH_CACHE_PATH)
+    print(f"Batch cached to {BATCH_CACHE_PATH}")
+
+inputs, targets = batch
+inputs, targets = inputs.to(device), targets.to(device)
+
+snr_stats = {}
+
+for advantage_type in ADVANTAGE_TYPES:
+    snr_stats[advantage_type] = {}
+    for N in ROLLOUT_COUNTS:
+        print(f"\n[advantage={advantage_type}, N={N}] collecting {S} gradient samples...")
+        try:
+            all_grads = []
+
+            num_minibatches = BATCH_SIZE // MINI_BATCH_SIZE
+
+            for s in tqdm(range(S)):
+                model.zero_grad()
+
+                for mb_start in range(0, BATCH_SIZE, MINI_BATCH_SIZE):
+                    mb_inputs  = inputs [mb_start : mb_start + MINI_BATCH_SIZE]
+                    mb_targets = targets[mb_start : mb_start + MINI_BATCH_SIZE]
+
+                    logits = model(mb_inputs)
+
+                    loss = calculate_loss(
+                        logits=logits,
+                        targets=mb_targets,
+                        num_train_rollouts_per_example=N,
+                        advantage_type=advantage_type,
+                        max_k=None,
+                    )
+
+                    # scale so accumulated gradient == average over full batch
+                    (loss / num_minibatches).backward()
+
+                flat_grad = torch.cat([
+                    p.grad.detach().view(-1)
+                    for p in model.parameters()
+                    if p.grad is not None
+                ])
+                all_grads.append(flat_grad)
+
+            gradients = torch.stack(all_grads)  # (S, D)
+            snr, mean_sq_norm, var_sum = gradient_snr(gradients)
+            snr, mean_sq_norm, var_sum = snr.item(), mean_sq_norm.item(), var_sum.item()
+            print(f"  SNR = {snr:.6f}, mean = {mean_sq_norm:.6f}, var = {var_sum:.6f}")
+            snr_stats[advantage_type][N] = {
+                "snr":  snr,
+                "mean": mean_sq_norm,
+                "var":  var_sum,
+            }
+
+        except Exception as e:
+            print(f"  ERROR: {e}")
+            snr_stats[advantage_type][N] = None
+
+with open(SNR_STATS_PATH, "w") as f:
+    json.dump(snr_stats, f, indent=2)
+
+print(f"\nSaved SNR stats to {SNR_STATS_PATH}")
+
+# --- Plot ---
+LABEL_MAP = {
+    "reinforce_with_baseline":       "RLOO",
+    "grpo":                          "GRPO",
+    "reinforce_with_p_normalization": "MaxRL",
+}
+
+with open(SNR_STATS_PATH) as f:
+    plot_data = json.load(f)
+
+fig, ax = plt.subplots(figsize=(8, 5))
+
+for advantage_type, rollout_snrs in plot_data.items():
+    xs = [int(k) for k in rollout_snrs]
+    ys = [v["snr"] if isinstance(v, dict) else v for v in rollout_snrs.values()]
+    label = LABEL_MAP.get(advantage_type, advantage_type)
+    ax.plot(xs, ys, marker="o", label=label)
+
+ax.set_xscale("log", base=2)
+ax.set_xlabel("Rollouts (N)")
+ax.set_ylabel("Gradient SNR")
+ax.set_title(f"Gradient SNR vs Rollouts  (S={S} gradient samples)")
+ax.legend()
+ax.grid(True, which="both", linestyle="--", alpha=0.5)
+
+plt.tight_layout()
+plt.savefig("snr.png", dpi=150)
+print("Saved plot to snr.png")

data/Maze/variance/0000.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2555071921d6b00d268ce92ecb9a83d95572f88da90bd6b43e7dd5c818681e1c
+size 3839835920

data/Maze/variance/5000.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a220dcd2bb4f8deb217c261cd11591c4a50f19b34c5d2d4927b273bcb778dc7c
+size 3874320653

data/Maze/variance/8000.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7454efc155e9dbfe987db40abfc89925d3c3e24eca383ad13b5ce83e58b12fcf
+size 3943981305

data/Qwen3/1.7b_512x512.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a5c57ae4437ad668abaab5f1f5b162e72d3b53a34fc25f9047223c9a4b5ee34c
+size 1722861371

data/Qwen3/4b_1024x128.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06b435d223068ec13f85407068b385fd56cc8c29e001aaca3f42ff4e489a1222
+size 1063867627

data/README.md

@@ -0,0 +1,18 @@
+This directory contains data of the following:
+
+1. SmolLM + GSM8k
+
+- Model: [SmolLM_MaxRL_rollout128_step1000](https://huggingface.co/guanning-ai/smollm2_0.3B_MaxRL_gsm8k_1000_steps)
+- Dataset: 512 prompts x 512 rollouts in GSM8k Training set
+
+2. Qwen Math
+
+- Model: [Qwen3-1.7B_MaxRL_1000steps](https://huggingface.co/collections/ftajwar/maxrl)
+- Dataset: 512 prompts x 512 rollouts in Polaris-53K dataset
+- Model: [Qwen3-4B_MaxRL_1000steps](https://huggingface.co/collections/ftajwar/maxrl)
+- Dataset: 1024 prompts x 128 rollouts in Polaris-53K dataset
+
+3. Maze
+
+- Models: [Maze17_bz256_ns64(0,5000,8000steps)](https://huggingface.co/guanning-ai/Qwen2-3M_MaxRL_Maze17_bz256_ns64)
+- Dataset: [Maze17_train_parquet](https://huggingface.co/datasets/guanning-ai/maze_17x17_1m), 2048 prompts x 1024 rollouts for each prompt

data/SmolLM/512x512.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:42a837cf816ec490629bf0e81959ad430ed2bb6106c799efb2f7fd65c9d64067
+size 294900706

maze_variance_analysis_auto.py

@@ -0,0 +1,400 @@
+"""
+Automated Maze Variance Analysis for MaxRL Policy Gradient.
+
+Runs all 12 experiments (6 rollout_nums x 2 baseline settings) across multiple
+GPUs with dynamic scheduling. Each GPU worker loads the model once and pulls
+experiments from a shared task pool. Saves only trace_covariance mean/std to
+outputs/ and plots the variance line chart.
+"""
+
+import json
+import os
+import random
+from functools import partial
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.multiprocessing as mp
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# ============================================================================
+# Configuration
+# ============================================================================
+BATCH_SIZE = 256
+ROLLOUT_NUMS = [4, 8, 16, 32, 64, 128, 256]
+NUMBER_BATCHES_PER_ROUND = 4
+TOTAL_ROUNDS = 128
+MICRO_BATCH_SIZE = 1024
+MAX_SEQ_LEN = 512
+SEED = 42
+
+MODEL_PATH = "/work/nvme/bgif/gzeng/MAXRL/checkpoints/maze/Qwen2-3M_MaxRL_Maze17_bz256_ns64/step5000"
+DATA_PATH = "/work/nvme/bgif/gzeng/MAXRL/variance_analysis/data/Maze/variance/5000.jsonl"
+
+GPU_IDS = [0, 1, 2, 3]
+DTYPE = torch.float32
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+OUTPUT_DIR = os.path.join(SCRIPT_DIR, "outputs", "Maze")
+
+
+# ============================================================================
+# Per-worker global state (initialized once per GPU worker)
+# ============================================================================
+_worker_model = None
+_worker_tokenizer = None
+_worker_prompt_data = None
+_worker_all_prompt_ids = None
+_worker_total_params = None
+_worker_device = None
+
+
+def worker_init(gpu_queue: mp.Queue):
+    """Called once per pool worker. Grabs a GPU and loads model + data."""
+    global _worker_model, _worker_tokenizer, _worker_prompt_data
+    global _worker_all_prompt_ids, _worker_total_params, _worker_device
+
+    gpu_id = gpu_queue.get()
+    _worker_device = f"cuda:{gpu_id}"
+    print(f"[Worker PID={os.getpid()}] Assigned to GPU {gpu_id}")
+
+    _worker_tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
+    if _worker_tokenizer.pad_token is None:
+        _worker_tokenizer.pad_token = _worker_tokenizer.eos_token
+
+    _worker_model = AutoModelForCausalLM.from_pretrained(
+        MODEL_PATH, torch_dtype=DTYPE,
+    ).to(_worker_device)
+    _worker_model.eval()
+    for p in _worker_model.parameters():
+        p.requires_grad_(True)
+
+    _worker_total_params = sum(p.numel() for p in _worker_model.parameters())
+    print(f"[GPU {gpu_id}] Model loaded: {_worker_total_params:,} parameters")
+
+    _worker_prompt_data = load_rollout_data(DATA_PATH)
+    _worker_all_prompt_ids = list(_worker_prompt_data.keys())
+
+
+# ============================================================================
+# Data Loading
+# ============================================================================
+def load_rollout_data(data_path: str) -> dict:
+    prompt_to_id = {}
+    prompt_data = {}
+
+    with open(data_path, "r") as f:
+        for line in f:
+            item = json.loads(line)
+            prompt_text = item["input"]
+            if prompt_text not in prompt_to_id:
+                pid = len(prompt_to_id)
+                prompt_to_id[prompt_text] = pid
+                prompt_data[pid] = {"input": prompt_text, "rollouts": []}
+            pid = prompt_to_id[prompt_text]
+            prompt_data[pid]["rollouts"].append({
+                "output": item["output"],
+                "score": item["score"],
+            })
+
+    print(f"Loaded {len(prompt_data)} prompts, "
+          f"each with {len(prompt_data[0]['rollouts'])} rollouts")
+    return prompt_data
+
+
+# ============================================================================
+# MaxRL Advantage Computation
+# ============================================================================
+def compute_maxrl_advantage(
+    scores: list[float], baseline: bool, epsilon: float = 1e-6,
+) -> list[float]:
+    mean = sum(scores) / len(scores)
+    if baseline:
+        return [(s - mean) / (mean + epsilon) for s in scores]
+    else:
+        return [s / (mean + epsilon) for s in scores]
+
+
+# ============================================================================
+# Tokenization & Batching
+# ============================================================================
+def tokenize_and_get_response_mask(
+    tokenizer, prompt: str, response: str, max_seq_len: int,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    prompt_ids = tokenizer.encode(prompt, add_special_tokens=False)
+    response_ids = tokenizer.encode(response, add_special_tokens=False)
+
+    total_len = len(prompt_ids) + len(response_ids)
+    if total_len > max_seq_len:
+        max_resp = max_seq_len - len(prompt_ids)
+        if max_resp <= 0:
+            prompt_ids = prompt_ids[:max_seq_len // 2]
+            max_resp = max_seq_len - len(prompt_ids)
+        response_ids = response_ids[:max_resp]
+
+    input_ids = prompt_ids + response_ids
+    response_mask = [0] * len(prompt_ids) + [1] * len(response_ids)
+
+    return (
+        torch.tensor(input_ids, dtype=torch.long),
+        torch.tensor(response_mask, dtype=torch.float32),
+    )
+
+
+def pad_batch(
+    batch_input_ids: list[torch.Tensor],
+    batch_response_masks: list[torch.Tensor],
+    pad_token_id: int,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    max_len = max(ids.shape[0] for ids in batch_input_ids)
+    B = len(batch_input_ids)
+
+    input_ids = torch.full((B, max_len), pad_token_id, dtype=torch.long)
+    response_mask = torch.zeros(B, max_len)
+    attention_mask = torch.zeros(B, max_len)
+
+    for i, (ids, rmask) in enumerate(zip(batch_input_ids, batch_response_masks)):
+        seq_len = ids.shape[0]
+        input_ids[i, max_len - seq_len:] = ids
+        response_mask[i, max_len - seq_len:] = rmask
+        attention_mask[i, max_len - seq_len:] = 1.0
+
+    return input_ids, response_mask, attention_mask
+
+
+# ============================================================================
+# Policy Gradient Loss
+# ============================================================================
+def compute_policy_gradient_loss(
+    model, input_ids, attention_mask, response_mask, advantages,
+) -> tuple[torch.Tensor, int]:
+    outputs = model(input_ids=input_ids, attention_mask=attention_mask)
+    logits = outputs.logits
+
+    shift_logits = logits[:, :-1, :]
+    shift_labels = input_ids[:, 1:]
+    shift_response_mask = response_mask[:, 1:]
+
+    log_probs = torch.log_softmax(shift_logits, dim=-1)
+    token_log_probs = torch.gather(
+        log_probs, dim=-1, index=shift_labels.unsqueeze(-1),
+    ).squeeze(-1)
+
+    token_losses = -advantages.unsqueeze(-1) * token_log_probs * shift_response_mask
+    valid_token_count = int(shift_response_mask.sum().item())
+    loss = token_losses.sum() / max(valid_token_count, 1)
+    return loss, valid_token_count
+
+
+# ============================================================================
+# Gradient Utilities
+# ============================================================================
+def collect_flat_gradient(model) -> torch.Tensor:
+    grads = []
+    for p in model.parameters():
+        if p.grad is not None:
+            grads.append(p.grad.detach().float().flatten())
+        else:
+            grads.append(torch.zeros(p.numel(), dtype=torch.float32, device=p.device))
+    return torch.cat(grads)
+
+
+def compute_trace_variance(
+    grad_sum: torch.Tensor, grad_sq_sum: torch.Tensor, K: int,
+) -> float:
+    grad_mean = grad_sum / K
+    elementwise_var = (grad_sq_sum / K - grad_mean ** 2) * (K / (K - 1))
+    return elementwise_var.sum().item()
+
+
+# ============================================================================
+# Single Experiment (runs inside a worker process)
+# ============================================================================
+def run_single_experiment(task: tuple[int, bool]) -> tuple[str, dict]:
+    """Run one experiment using the worker's pre-loaded model and data.
+
+    Args:
+        task: (rollout_num, baseline)
+
+    Returns:
+        (key, {"mean": float, "std": float})
+    """
+    rollout_num, baseline = task
+    key = f"nr{rollout_num}_bl{baseline}"
+
+    model = _worker_model
+    tokenizer = _worker_tokenizer
+    prompt_data = _worker_prompt_data
+    all_prompt_ids = _worker_all_prompt_ids
+    total_params = _worker_total_params
+    device = _worker_device
+
+    print(f"[{device}] Starting {key}")
+
+    random.seed(SEED)
+    np.random.seed(SEED)
+    torch.manual_seed(SEED)
+
+    trace_variances = []
+
+    for round_idx in range(TOTAL_ROUNDS):
+        sampled_prompts = random.sample(all_prompt_ids, BATCH_SIZE)
+
+        rollouts_needed = NUMBER_BATCHES_PER_ROUND * rollout_num
+        round_rollout_subsets = {}
+        for pid in sampled_prompts:
+            rollouts = prompt_data[pid]["rollouts"]
+            if len(rollouts) < rollouts_needed:
+                raise ValueError(
+                    f"Prompt {pid} has {len(rollouts)} rollouts, need {rollouts_needed}"
+                )
+            sampled = random.sample(rollouts, rollouts_needed)
+            round_rollout_subsets[pid] = [
+                sampled[s:s + rollout_num]
+                for s in range(0, rollouts_needed, rollout_num)
+            ]
+
+        grad_sum = torch.zeros(total_params, dtype=torch.float32)
+        grad_sq_sum = torch.zeros(total_params, dtype=torch.float32)
+
+        for subset_idx in range(NUMBER_BATCHES_PER_ROUND):
+            all_input_ids = []
+            all_response_masks = []
+            all_advantages = []
+
+            for pid in sampled_prompts:
+                prompt_text = prompt_data[pid]["input"]
+                sampled_rollouts = round_rollout_subsets[pid][subset_idx]
+                scores = [r["score"] for r in sampled_rollouts]
+                advantages = compute_maxrl_advantage(scores, baseline)
+
+                for rollout, adv in zip(sampled_rollouts, advantages):
+                    ids, rmask = tokenize_and_get_response_mask(
+                        tokenizer, prompt_text, rollout["output"], MAX_SEQ_LEN,
+                    )
+                    all_input_ids.append(ids)
+                    all_response_masks.append(rmask)
+                    all_advantages.append(adv)
+
+            model.zero_grad()
+            total_valid_tokens = int(
+                sum(rmask[1:].sum().item() for rmask in all_response_masks)
+            )
+            num_samples = len(all_input_ids)
+
+            for mb_start in range(0, num_samples, MICRO_BATCH_SIZE):
+                mb_end = min(mb_start + MICRO_BATCH_SIZE, num_samples)
+
+                mb_ids = all_input_ids[mb_start:mb_end]
+                mb_masks = all_response_masks[mb_start:mb_end]
+                mb_advs = all_advantages[mb_start:mb_end]
+
+                input_ids, response_mask, attention_mask = pad_batch(
+                    mb_ids, mb_masks, tokenizer.pad_token_id,
+                )
+                input_ids = input_ids.to(device)
+                response_mask = response_mask.to(device)
+                attention_mask = attention_mask.to(device)
+                advantages_t = torch.tensor(mb_advs, dtype=DTYPE, device=device)
+
+                mb_loss, mb_valid_tokens = compute_policy_gradient_loss(
+                    model, input_ids, attention_mask, response_mask, advantages_t,
+                )
+                scaled_loss = mb_loss * (mb_valid_tokens / max(total_valid_tokens, 1))
+                scaled_loss.backward()
+
+            flat_grad = collect_flat_gradient(model).cpu()
+            grad_sum += flat_grad
+            grad_sq_sum += flat_grad ** 2
+
+        trace_var = compute_trace_variance(
+            grad_sum, grad_sq_sum, NUMBER_BATCHES_PER_ROUND,
+        )
+        trace_variances.append(trace_var)
+        print(f"  [{device}] {key} round {round_idx+1}/{TOTAL_ROUNDS}: "
+              f"trace_cov={trace_var:.6e}")
+
+    result = {
+        "mean": float(np.mean(trace_variances)),
+        "std": float(np.std(trace_variances)),
+    }
+    print(f"[{device}] Finished {key}: mean={result['mean']:.6e}, std={result['std']:.6e}")
+    return key, result
+
+
+# ============================================================================
+# Plotting
+# ============================================================================
+def plot_results(results: dict, output_dir: str):
+    rollout_nums = ROLLOUT_NUMS
+
+    means_bl_true = [results[f"nr{nr}_blTrue"]["mean"] for nr in rollout_nums]
+    means_bl_false = [results[f"nr{nr}_blFalse"]["mean"] for nr in rollout_nums]
+
+    fig, ax = plt.subplots(figsize=(7, 5))
+
+    ax.plot(rollout_nums, means_bl_true, marker='o', label='MaxRL')
+    ax.plot(rollout_nums, means_bl_false, marker='s', label='MaxRL (w/o baseline)')
+
+    ax.set_xscale('log', base=2)
+    ax.set_xticks(rollout_nums)
+    ax.set_xticklabels(rollout_nums)
+    ax.set_xlabel('Rollout', fontsize=14)
+    ax.set_ylabel('Gradient Variance', fontsize=14)
+    ax.legend(fontsize=12)
+    ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    plt.savefig(os.path.join(output_dir, "variance_plot.pdf"), dpi=300)
+    plt.savefig(os.path.join(output_dir, "variance_plot.png"), dpi=300)
+    print(f"Plots saved to {output_dir}/variance_plot.{{pdf,png}}")
+
+
+# ============================================================================
+# Main
+# ============================================================================
+def main():
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    # Build task list: 12 experiments
+    tasks = []
+    for rollout_num in ROLLOUT_NUMS:
+        for baseline in [True, False]:
+            tasks.append((rollout_num, baseline))
+
+    print(f"Scheduling {len(tasks)} experiments across {len(GPU_IDS)} GPUs")
+
+    # GPU queue: each worker grabs one GPU ID on init
+    gpu_queue = mp.Queue()
+    for gid in GPU_IDS:
+        gpu_queue.put(gid)
+
+    # Pool of workers = number of GPUs. Each worker inits once (loads model),
+    # then processes tasks dynamically from the pool.
+    with mp.Pool(
+        processes=len(GPU_IDS),
+        initializer=worker_init,
+        initargs=(gpu_queue,),
+    ) as pool:
+        results_list = pool.map(run_single_experiment, tasks)
+
+    # Collect results
+    results = dict(results_list)
+
+    # Save
+    results_path = os.path.join(OUTPUT_DIR, "results.json")
+    with open(results_path, "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"Results saved to {results_path}")
+
+    # Plot
+    plot_results(results, OUTPUT_DIR)
+    print("All done!")
+
+
+if __name__ == "__main__":
+    mp.set_start_method("spawn")
+    main()

outputs/Maze/results.json

@@ -0,0 +1,58 @@
+{
+  "nr4_blTrue": {
+    "mean": 0.09343412215821445,
+    "std": 0.04141906356644995
+  },
+  "nr4_blFalse": {
+    "mean": 0.1171639968524687,
+    "std": 0.06142266485721379
+  },
+  "nr8_blTrue": {
+    "mean": 0.07531368439958896,
+    "std": 0.037395865364248826
+  },
+  "nr8_blFalse": {
+    "mean": 0.0812347744795261,
+    "std": 0.05446751649965604
+  },
+  "nr16_blTrue": {
+    "mean": 0.051791880556265824,
+    "std": 0.032323674211987063
+  },
+  "nr16_blFalse": {
+    "mean": 0.056146801136492286,
+    "std": 0.03758377689938391
+  },
+  "nr32_blTrue": {
+    "mean": 0.04027390201736125,
+    "std": 0.03491190177211898
+  },
+  "nr32_blFalse": {
+    "mean": 0.04236685928481165,
+    "std": 0.03529769154208022
+  },
+  "nr64_blTrue": {
+    "mean": 0.02930887994079967,
+    "std": 0.029723109116621262
+  },
+  "nr64_blFalse": {
+    "mean": 0.030155911130350432,
+    "std": 0.02806844767402451
+  },
+  "nr128_blTrue": {
+    "mean": 0.023548210993794783,
+    "std": 0.027154330195472722
+  },
+  "nr128_blFalse": {
+    "mean": 0.02521930770672043,
+    "std": 0.03021973835553808
+  },
+  "nr256_blTrue": {
+    "mean": 0.017309359611317632,
+    "std": 0.01862850514229902
+  },
+  "nr256_blFalse": {
+    "mean": 0.017515211292220556,
+    "std": 0.018245087061411355
+  }
+}

outputs/Qwen3/.gitkeep

@@ -0,0 +1 @@
+

outputs/SmolLM/results.json

@@ -0,0 +1,50 @@
+{
+  "nr4_blTrue": {
+    "mean": 0.3461569035425782,
+    "std": 0.10700828370370079
+  },
+  "nr4_blFalse": {
+    "mean": 0.5613684519194067,
+    "std": 0.1363638089093747
+  },
+  "nr8_blTrue": {
+    "mean": 0.34889423102140427,
+    "std": 0.11797077527297667
+  },
+  "nr8_blFalse": {
+    "mean": 0.46802500914782286,
+    "std": 0.13111071007542788
+  },
+  "nr16_blTrue": {
+    "mean": 0.27634103666059673,
+    "std": 0.09890688698321183
+  },
+  "nr16_blFalse": {
+    "mean": 0.345704042352736,
+    "std": 0.10513549380879457
+  },
+  "nr32_blTrue": {
+    "mean": 0.26002368051558733,
+    "std": 0.12564290483305135
+  },
+  "nr32_blFalse": {
+    "mean": 0.29659369541332126,
+    "std": 0.13365507973097127
+  },
+  "nr64_blTrue": {
+    "mean": 0.2039303722558543,
+    "std": 0.1140506321981112
+  },
+  "nr64_blFalse": {
+    "mean": 0.2275285553187132,
+    "std": 0.11667669231022332
+  },
+  "nr128_blTrue": {
+    "mean": 0.1596078732982278,
+    "std": 0.07754145558626176
+  },
+  "nr128_blFalse": {
+    "mean": 0.17232763615902513,
+    "std": 0.07963091239252962
+  }
+}

outputs/SmolLM_SNR/.gitkeep

@@ -0,0 +1 @@
+

outputs/old/results_bs16_nr128_nb4_r5_blFalse.json

@@ -0,0 +1,80 @@
+{
+  "config": {
+    "batch_size": 16,
+    "rollout_num": 128,
+    "number_batches_per_round": 4,
+    "total_rounds": 5,
+    "model_path": "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/smollm2_0.3B_MaxRL_gsm8k_1000_steps",
+    "max_seq_len": 2048,
+    "seed": 42,
+    "baseline": false
+  },
+  "per_round": [
+    {
+      "mean_grad_norm": 0.7689405679702759,
+      "trace_variance": 0.2869313657283783,
+      "relative_variance": 0.4852800940577739,
+      "avg_sample_grad_norm": 0.8799326419830322,
+      "std_sample_grad_norm": 0.1096991376772517,
+      "avg_cosine_similarity_to_mean": 0.9405284523963928
+    },
+    {
+      "mean_grad_norm": 0.8357224464416504,
+      "trace_variance": 0.15966498851776123,
+      "relative_variance": 0.22860491326781845,
+      "avg_sample_grad_norm": 0.8944469094276428,
+      "std_sample_grad_norm": 0.07733634177736912,
+      "avg_cosine_similarity_to_mean": 0.9950093924999237
+    },
+    {
+      "mean_grad_norm": 0.6839278936386108,
+      "trace_variance": 0.08836942911148071,
+      "relative_variance": 0.18892151348330627,
+      "avg_sample_grad_norm": 0.725984051823616,
+      "std_sample_grad_norm": 0.029560648578731755,
+      "avg_cosine_similarity_to_mean": 1.011790782213211
+    },
+    {
+      "mean_grad_norm": 0.7902998328208923,
+      "trace_variance": 0.06472273916006088,
+      "relative_variance": 0.1036270437226223,
+      "avg_sample_grad_norm": 0.8173244595527649,
+      "std_sample_grad_norm": 0.020897730886255742,
+      "avg_cosine_similarity_to_mean": 1.0311751067638397
+    },
+    {
+      "mean_grad_norm": 0.8064079284667969,
+      "trace_variance": 0.15503337979316711,
+      "relative_variance": 0.2384051522286745,
+      "avg_sample_grad_norm": 0.868552565574646,
+      "std_sample_grad_norm": 0.03490493615590108,
+      "avg_cosine_similarity_to_mean": 0.9947420358657837
+    }
+  ],
+  "averaged": {
+    "mean_grad_norm": {
+      "mean": 0.7770597338676453,
+      "std": 0.05141476657999565
+    },
+    "trace_variance": {
+      "mean": 0.15094438046216965,
+      "std": 0.07737573915323949
+    },
+    "relative_variance": {
+      "mean": 0.2489677433520391,
+      "std": 0.12735714268667106
+    },
+    "avg_sample_grad_norm": {
+      "mean": 0.8372481256723404,
+      "std": 0.06140078721713483
+    },
+    "std_sample_grad_norm": {
+      "mean": 0.05447975901510188,
+      "std": 0.03377422544946952
+    },
+    "avg_cosine_similarity_to_mean": {
+      "mean": 0.9946491539478302,
+      "std": 0.03018996317980766
+    }
+  }
+}

outputs/old/results_bs16_nr128_nb4_r5_blTrue.json

@@ -0,0 +1,80 @@
+{
+  "config": {
+    "batch_size": 16,
+    "rollout_num": 128,
+    "number_batches_per_round": 4,
+    "total_rounds": 5,
+    "model_path": "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/smollm2_0.3B_MaxRL_gsm8k_1000_steps",
+    "max_seq_len": 2048,
+    "seed": 42,
+    "baseline": true
+  },
+  "per_round": [
+    {
+      "mean_grad_norm": 0.3161277174949646,
+      "trace_variance": 0.27833467721939087,
+      "relative_variance": 2.7851088027893787,
+      "avg_sample_grad_norm": 0.5257724076509476,
+      "std_sample_grad_norm": 0.1253468533977172,
+      "avg_cosine_similarity_to_mean": 0.6508230715990067
+    },
+    {
+      "mean_grad_norm": 0.23199908435344696,
+      "trace_variance": 0.15211263298988342,
+      "relative_variance": 2.8261339442659383,
+      "avg_sample_grad_norm": 0.3839375451207161,
+      "std_sample_grad_norm": 0.10596379740421964,
+      "avg_cosine_similarity_to_mean": 0.6401898264884949
+    },
+    {
+      "mean_grad_norm": 0.22157494723796844,
+      "trace_variance": 0.07338934391736984,
+      "relative_variance": 1.4948296214837793,
+      "avg_sample_grad_norm": 0.3141995221376419,
+      "std_sample_grad_norm": 0.02690045819675988,
+      "avg_cosine_similarity_to_mean": 0.7678444683551788
+    },
+    {
+      "mean_grad_norm": 0.2028011679649353,
+      "trace_variance": 0.05692358687520027,
+      "relative_variance": 1.3840486413650959,
+      "avg_sample_grad_norm": 0.2825518846511841,
+      "std_sample_grad_norm": 0.01270163227318277,
+      "avg_cosine_similarity_to_mean": 0.7714781761169434
+    },
+    {
+      "mean_grad_norm": 0.2694803774356842,
+      "trace_variance": 0.14570380747318268,
+      "relative_variance": 2.0063957823319107,
+      "avg_sample_grad_norm": 0.4091017544269562,
+      "std_sample_grad_norm": 0.07354999374759726,
+      "avg_cosine_similarity_to_mean": 0.715828612446785
+    }
+  ],
+  "averaged": {
+    "mean_grad_norm": {
+      "mean": 0.2483966588973999,
+      "std": 0.040247367483568344
+    },
+    "trace_variance": {
+      "mean": 0.1412928096950054,
+      "std": 0.07828926536369483
+    },
+    "relative_variance": {
+      "mean": 2.0993033584472203,
+      "std": 0.613876442723994
+    },
+    "avg_sample_grad_norm": {
+      "mean": 0.38311262279748914,
+      "std": 0.08472237859410245
+    },
+    "std_sample_grad_norm": {
+      "mean": 0.06889254700389535,
+      "std": 0.043597735141821393
+    },
+    "avg_cosine_similarity_to_mean": {
+      "mean": 0.7092328310012818,
+      "std": 0.05573499407075196
+    }
+  }
+}

outputs/old/results_bs16_nr16_nb4_r5_blFalse.json

@@ -0,0 +1,80 @@
+{
+  "config": {
+    "batch_size": 16,
+    "rollout_num": 16,
+    "number_batches_per_round": 4,
+    "total_rounds": 5,
+    "model_path": "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/smollm2_0.3B_MaxRL_gsm8k_1000_steps",
+    "max_seq_len": 2048,
+    "seed": 42,
+    "baseline": false
+  },
+  "per_round": [
+    {
+      "mean_grad_norm": 0.6964784264564514,
+      "trace_variance": 0.3348350524902344,
+      "relative_variance": 0.6902645643219107,
+      "avg_sample_grad_norm": 0.8420403301715851,
+      "std_sample_grad_norm": 0.07201185501512579,
+      "avg_cosine_similarity_to_mean": 0.8888210356235504
+    },
+    {
+      "mean_grad_norm": 0.8008900880813599,
+      "trace_variance": 0.4339163601398468,
+      "relative_variance": 0.6764881401105687,
+      "avg_sample_grad_norm": 0.9527603536844254,
+      "std_sample_grad_norm": 0.1757878804217989,
+      "avg_cosine_similarity_to_mean": 0.8986288011074066
+    },
+    {
+      "mean_grad_norm": 0.7970862984657288,
+      "trace_variance": 0.4751781225204468,
+      "relative_variance": 0.7479038165554954,
+      "avg_sample_grad_norm": 0.9778163135051727,
+      "std_sample_grad_norm": 0.05700159387678907,
+      "avg_cosine_similarity_to_mean": 0.8750215619802475
+    },
+    {
+      "mean_grad_norm": 0.6043644547462463,
+      "trace_variance": 0.35235679149627686,
+      "relative_variance": 0.9646834306882995,
+      "avg_sample_grad_norm": 0.7641780376434326,
+      "std_sample_grad_norm": 0.15278308552449663,
+      "avg_cosine_similarity_to_mean": 0.8460912108421326
+    },
+    {
+      "mean_grad_norm": 0.5035268068313599,
+      "trace_variance": 0.30590248107910156,
+      "relative_variance": 1.2065291143381554,
+      "avg_sample_grad_norm": 0.6727220565080643,
+      "std_sample_grad_norm": 0.09560943366609909,
+      "avg_cosine_similarity_to_mean": 0.8143545389175415
+    }
+  ],
+  "averaged": {
+    "mean_grad_norm": {
+      "mean": 0.6804692149162292,
+      "std": 0.11441815941797533
+    },
+    "trace_variance": {
+      "mean": 0.3804377615451813,
+      "std": 0.06365430463302185
+    },
+    "relative_variance": {
+      "mean": 0.8571738132028859,
+      "std": 0.20300413112709334
+    },
+    "avg_sample_grad_norm": {
+      "mean": 0.841903418302536,
+      "std": 0.11438982640665354
+    },
+    "std_sample_grad_norm": {
+      "mean": 0.11063876970086188,
+      "std": 0.04607692718517292
+    },
+    "avg_cosine_similarity_to_mean": {
+      "mean": 0.8645834296941757,
+      "std": 0.030725907922132888
+    }
+  }
+}

outputs/old/results_bs16_nr16_nb4_r5_blTrue.json

@@ -0,0 +1,80 @@
+{
+  "config": {
+    "batch_size": 16,
+    "rollout_num": 16,
+    "number_batches_per_round": 4,
+    "total_rounds": 5,
+    "model_path": "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/smollm2_0.3B_MaxRL_gsm8k_1000_steps",
+    "max_seq_len": 2048,
+    "seed": 42,
+    "baseline": true
+  },
+  "per_round": [
+    {
+      "mean_grad_norm": 0.2737724781036377,
+      "trace_variance": 0.2792177200317383,
+      "relative_variance": 3.7253184368368504,
+      "avg_sample_grad_norm": 0.5060313940048218,
+      "std_sample_grad_norm": 0.10218939775503928,
+      "avg_cosine_similarity_to_mean": 0.5696069896221161
+    },
+    {
+      "mean_grad_norm": 0.32015320658683777,
+      "trace_variance": 0.31460481882095337,
+      "relative_variance": 3.069372926299306,
+      "avg_sample_grad_norm": 0.541322261095047,
+      "std_sample_grad_norm": 0.163643840876535,
+      "avg_cosine_similarity_to_mean": 0.5857272818684578
+    },
+    {
+      "mean_grad_norm": 0.377981960773468,
+      "trace_variance": 0.41017645597457886,
+      "relative_variance": 2.870969514051388,
+      "avg_sample_grad_norm": 0.6466762721538544,
+      "std_sample_grad_norm": 0.08176618746444127,
+      "avg_cosine_similarity_to_mean": 0.6339955478906631
+    },
+    {
+      "mean_grad_norm": 0.2758277654647827,
+      "trace_variance": 0.2821664810180664,
+      "relative_variance": 3.708766223976379,
+      "avg_sample_grad_norm": 0.5054576545953751,
+      "std_sample_grad_norm": 0.12428782340874198,
+      "avg_cosine_similarity_to_mean": 0.5777123421430588
+    },
+    {
+      "mean_grad_norm": 0.2792853116989136,
+      "trace_variance": 0.2728402018547058,
+      "relative_variance": 3.497938505582848,
+      "avg_sample_grad_norm": 0.5002564936876297,
+      "std_sample_grad_norm": 0.11702612906514184,
+      "avg_cosine_similarity_to_mean": 0.5859523713588715
+    }
+  ],
+  "averaged": {
+    "mean_grad_norm": {
+      "mean": 0.30540414452552794,
+      "std": 0.04010633912538859
+    },
+    "trace_variance": {
+      "mean": 0.31180113554000854,
+      "std": 0.051270674618136725
+    },
+    "relative_variance": {
+      "mean": 3.3744731213493546,
+      "std": 0.34545333304198694
+    },
+    "avg_sample_grad_norm": {
+      "mean": 0.5399488151073456,
+      "std": 0.055331995136430764
+    },
+    "std_sample_grad_norm": {
+      "mean": 0.11778267571397986,
+      "std": 0.027153171169363003
+    },
+    "avg_cosine_similarity_to_mean": {
+      "mean": 0.5905989065766335,
+      "std": 0.022518062147937085
+    }
+  }
+}

outputs/old/results_bs16_nr32_nb4_r5_blFalse.json

@@ -0,0 +1,80 @@
+{
+  "config": {
+    "batch_size": 16,
+    "rollout_num": 32,
+    "number_batches_per_round": 4,
+    "total_rounds": 5,
+    "model_path": "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/smollm2_0.3B_MaxRL_gsm8k_1000_steps",
+    "max_seq_len": 2048,
+    "seed": 42,
+    "baseline": false
+  },
+  "per_round": [
+    {
+      "mean_grad_norm": 0.7721027135848999,
+      "trace_variance": 0.3138512372970581,
+      "relative_variance": 0.526470071209843,
+      "avg_sample_grad_norm": 0.8968465626239777,
+      "std_sample_grad_norm": 0.08699080250453943,
+      "avg_cosine_similarity_to_mean": 0.9272608906030655
+    },
+    {
+      "mean_grad_norm": 0.76179438829422,
+      "trace_variance": 0.2826382517814636,
+      "relative_variance": 0.48702964807005555,
+      "avg_sample_grad_norm": 0.8696170151233673,
+      "std_sample_grad_norm": 0.12881966504374284,
+      "avg_cosine_similarity_to_mean": 0.9404138624668121
+    },
+    {
+      "mean_grad_norm": 0.6628957390785217,
+      "trace_variance": 0.35148754715919495,
+      "relative_variance": 0.7998701464789485,
+      "avg_sample_grad_norm": 0.8236571550369263,
+      "std_sample_grad_norm": 0.024779726969064976,
+      "avg_cosine_similarity_to_mean": 0.8674887269735336
+    },
+    {
+      "mean_grad_norm": 0.8706740736961365,
+      "trace_variance": 0.3642888367176056,
+      "relative_variance": 0.48054563614774876,
+      "avg_sample_grad_norm": 1.0016238987445831,
+      "std_sample_grad_norm": 0.03215233180573083,
+      "avg_cosine_similarity_to_mean": 0.9396774470806122
+    },
+    {
+      "mean_grad_norm": 0.6275550723075867,
+      "trace_variance": 0.30897197127342224,
+      "relative_variance": 0.784540549413837,
+      "avg_sample_grad_norm": 0.7746196091175079,
+      "std_sample_grad_norm": 0.05964617988155661,
+      "avg_cosine_similarity_to_mean": 0.8722260743379593
+    }
+  ],
+  "averaged": {
+    "mean_grad_norm": {
+      "mean": 0.739004397392273,
+      "std": 0.08621515622002149
+    },
+    "trace_variance": {
+      "mean": 0.3242475688457489,
+      "std": 0.02972568723754252
+    },
+    "relative_variance": {
+      "mean": 0.6156912102640866,
+      "std": 0.14505896409400237
+    },
+    "avg_sample_grad_norm": {
+      "mean": 0.8732728481292724,
+      "std": 0.0764686287213851
+    },
+    "std_sample_grad_norm": {
+      "mean": 0.06647774124092694,
+      "std": 0.0381337894879539
+    },
+    "avg_cosine_similarity_to_mean": {
+      "mean": 0.9094134002923966,
+      "std": 0.032668178822674025
+    }
+  }
+}

outputs/old/results_bs16_nr32_nb4_r5_blTrue.json

@@ -0,0 +1,80 @@
+{
+  "config": {
+    "batch_size": 16,
+    "rollout_num": 32,
+    "number_batches_per_round": 4,
+    "total_rounds": 5,
+    "model_path": "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/smollm2_0.3B_MaxRL_gsm8k_1000_steps",
+    "max_seq_len": 2048,
+    "seed": 42,
+    "baseline": true
+  },
+  "per_round": [
+    {
+      "mean_grad_norm": 0.28896379470825195,
+      "trace_variance": 0.2879572808742523,
+      "relative_variance": 3.448587102812029,
+      "avg_sample_grad_norm": 0.505200058221817,
+      "std_sample_grad_norm": 0.16691583237670862,
+      "avg_cosine_similarity_to_mean": 0.5931130349636078
+    },
+    {
+      "mean_grad_norm": 0.2619099020957947,
+      "trace_variance": 0.23625493049621582,
+      "relative_variance": 3.444110237189513,
+      "avg_sample_grad_norm": 0.45509156957268715,
+      "std_sample_grad_norm": 0.15576454242091092,
+      "avg_cosine_similarity_to_mean": 0.5868209525942802
+    },
+    {
+      "mean_grad_norm": 0.30585452914237976,
+      "trace_variance": 0.3292638063430786,
+      "relative_variance": 3.519768999971907,
+      "avg_sample_grad_norm": 0.5639973282814026,
+      "std_sample_grad_norm": 0.01767149544944113,
+      "avg_cosine_similarity_to_mean": 0.592338502407074
+    },
+    {
+      "mean_grad_norm": 0.3031623363494873,
+      "trace_variance": 0.3239123523235321,
+      "relative_variance": 3.5243336693775595,
+      "avg_sample_grad_norm": 0.554802268743515,
+      "std_sample_grad_norm": 0.07338316736266386,
+      "avg_cosine_similarity_to_mean": 0.6006623655557632
+    },
+    {
+      "mean_grad_norm": 0.2689555287361145,
+      "trace_variance": 0.27706390619277954,
+      "relative_variance": 3.830178373994615,
+      "avg_sample_grad_norm": 0.5079697072505951,
+      "std_sample_grad_norm": 0.05607249553495662,
+      "avg_cosine_similarity_to_mean": 0.5773692056536674
+    }
+  ],
+  "averaged": {
+    "mean_grad_norm": {
+      "mean": 0.28576921820640566,
+      "std": 0.017709391361814476
+    },
+    "trace_variance": {
+      "mean": 0.2908904552459717,
+      "std": 0.03390509488651892
+    },
+    "relative_variance": {
+      "mean": 3.553395676669125,
+      "std": 0.14248660261828003
+    },
+    "avg_sample_grad_norm": {
+      "mean": 0.5174121864140033,
+      "std": 0.03921823420458731
+    },
+    "std_sample_grad_norm": {
+      "mean": 0.09396150662893624,
+      "std": 0.058001999780733754
+    },
+    "avg_cosine_similarity_to_mean": {
+      "mean": 0.5900608122348785,
+      "std": 0.007726194885257127
+    }
+  }
+}

outputs/old/results_bs16_nr4_nb4_r5_blFalse.json

@@ -0,0 +1,80 @@
+{
+  "config": {
+    "batch_size": 16,
+    "rollout_num": 4,
+    "number_batches_per_round": 4,
+    "total_rounds": 5,
+    "model_path": "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/smollm2_0.3B_MaxRL_gsm8k_1000_steps",
+    "max_seq_len": 2048,
+    "seed": 42,
+    "baseline": false
+  },
+  "per_round": [
+    {
+      "mean_grad_norm": 0.7435137629508972,
+      "trace_variance": 0.6554153561592102,
+      "relative_variance": 1.1856010859189596,
+      "avg_sample_grad_norm": 0.996780276298523,
+      "std_sample_grad_norm": 0.09697026173657458,
+      "avg_cosine_similarity_to_mean": 0.8014578223228455
+    },
+    {
+      "mean_grad_norm": 0.6562896370887756,
+      "trace_variance": 0.6258231401443481,
+      "relative_variance": 1.4529829690553044,
+      "avg_sample_grad_norm": 0.9213704764842987,
+      "std_sample_grad_norm": 0.11367962565706029,
+      "avg_cosine_similarity_to_mean": 0.767962858080864
+    },
+    {
+      "mean_grad_norm": 0.6826515197753906,
+      "trace_variance": 0.5123142004013062,
+      "relative_variance": 1.0993557972789034,
+      "avg_sample_grad_norm": 0.8889862895011902,
+      "std_sample_grad_norm": 0.1649224690024605,
+      "avg_cosine_similarity_to_mean": 0.81678107380867
+    },
+    {
+      "mean_grad_norm": 0.5915200114250183,
+      "trace_variance": 0.6056228876113892,
+      "relative_variance": 1.730865797634316,
+      "avg_sample_grad_norm": 0.8678804934024811,
+      "std_sample_grad_norm": 0.11112772837588089,
+      "avg_cosine_similarity_to_mean": 0.73161780834198
+    },
+    {
+      "mean_grad_norm": 0.780635416507721,
+      "trace_variance": 0.5549829006195068,
+      "relative_variance": 0.9107162812869151,
+      "avg_sample_grad_norm": 0.9906752854585648,
+      "std_sample_grad_norm": 0.08322465784960068,
+      "avg_cosine_similarity_to_mean": 0.8424067795276642
+    }
+  ],
+  "averaged": {
+    "mean_grad_norm": {
+      "mean": 0.6909220695495606,
+      "std": 0.06627661332380856
+    },
+    "trace_variance": {
+      "mean": 0.5908316969871521,
+      "std": 0.05111626535159937
+    },
+    "relative_variance": {
+      "mean": 1.2759043862348798,
+      "std": 0.28671698682220986
+    },
+    "avg_sample_grad_norm": {
+      "mean": 0.9331385642290115,
+      "std": 0.05235889392604594
+    },
+    "std_sample_grad_norm": {
+      "mean": 0.11398494852431537,
+      "std": 0.02770769918405064
+    },
+    "avg_cosine_similarity_to_mean": {
+      "mean": 0.7920452684164048,
+      "std": 0.03864758326071824
+    }
+  }
+}

outputs/old/results_bs16_nr4_nb4_r5_blTrue.json

@@ -0,0 +1,80 @@
+{
+  "config": {
+    "batch_size": 16,
+    "rollout_num": 4,
+    "number_batches_per_round": 4,
+    "total_rounds": 5,
+    "model_path": "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/smollm2_0.3B_MaxRL_gsm8k_1000_steps",
+    "max_seq_len": 2048,
+    "seed": 42,
+    "baseline": true
+  },
+  "per_round": [
+    {
+      "mean_grad_norm": 0.3311220407485962,
+      "trace_variance": 0.4140247106552124,
+      "relative_variance": 3.7761573424860275,
+      "avg_sample_grad_norm": 0.6195628046989441,
+      "std_sample_grad_norm": 0.10239149261311377,
+      "avg_cosine_similarity_to_mean": 0.5686733275651932
+    },
+    {
+      "mean_grad_norm": 0.509647786617279,
+      "trace_variance": 0.6342702507972717,
+      "relative_variance": 2.4419347611122593,
+      "avg_sample_grad_norm": 0.7901830524206161,
+      "std_sample_grad_norm": 0.2769427565102714,
+      "avg_cosine_similarity_to_mean": 0.6417316198348999
+    },
+    {
+      "mean_grad_norm": 0.2220628559589386,
+      "trace_variance": 0.24883511662483215,
+      "relative_variance": 5.046146175333274,
+      "avg_sample_grad_norm": 0.4583381339907646,
+      "std_sample_grad_norm": 0.09868455803698328,
+      "avg_cosine_similarity_to_mean": 0.5111349001526833
+    },
+    {
+      "mean_grad_norm": 0.3061383068561554,
+      "trace_variance": 0.38140782713890076,
+      "relative_variance": 4.069623654264621,
+      "avg_sample_grad_norm": 0.5863617360591888,
+      "std_sample_grad_norm": 0.10806355451567583,
+      "avg_cosine_similarity_to_mean": 0.5520333349704742
+    },
+    {
+      "mean_grad_norm": 0.23846779763698578,
+      "trace_variance": 0.2480362355709076,
+      "relative_variance": 4.361698572068804,
+      "avg_sample_grad_norm": 0.47311121225357056,
+      "std_sample_grad_norm": 0.06102951740547904,
+      "avg_cosine_similarity_to_mean": 0.5363884419202805
+    }
+  ],
+  "averaged": {
+    "mean_grad_norm": {
+      "mean": 0.321487757563591,
+      "std": 0.10247950662284001
+    },
+    "trace_variance": {
+      "mean": 0.3853148281574249,
+      "std": 0.14162658515570797
+    },
+    "relative_variance": {
+      "mean": 3.9391121010529973,
+      "std": 0.8589797754541765
+    },
+    "avg_sample_grad_norm": {
+      "mean": 0.5855113878846169,
+      "std": 0.11988123150089669
+    },
+    "std_sample_grad_norm": {
+      "mean": 0.12942237581630464,
+      "std": 0.07559302499255817
+    },
+    "avg_cosine_similarity_to_mean": {
+      "mean": 0.5619923248887062,
+      "std": 0.044145688145756264
+    }
+  }
+}

outputs/old/results_bs16_nr64_nb4_r5_blFalse.json

@@ -0,0 +1,80 @@
+{
+  "config": {
+    "batch_size": 16,
+    "rollout_num": 64,
+    "number_batches_per_round": 4,
+    "total_rounds": 5,
+    "model_path": "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/smollm2_0.3B_MaxRL_gsm8k_1000_steps",
+    "max_seq_len": 2048,
+    "seed": 42,
+    "baseline": false
+  },
+  "per_round": [
+    {
+      "mean_grad_norm": 0.7199326157569885,
+      "trace_variance": 0.16369977593421936,
+      "relative_variance": 0.3158380040035924,
+      "avg_sample_grad_norm": 0.7896079123020172,
+      "std_sample_grad_norm": 0.08840608429535818,
+      "avg_cosine_similarity_to_mean": 0.9801101982593536
+    },
+    {
+      "mean_grad_norm": 0.8231773972511292,
+      "trace_variance": 0.6244240999221802,
+      "relative_variance": 0.9214945738571112,
+      "avg_sample_grad_norm": 1.0009050518274307,
+      "std_sample_grad_norm": 0.3319705070724497,
+      "avg_cosine_similarity_to_mean": 0.8798657655715942
+    },
+    {
+      "mean_grad_norm": 0.9061974883079529,
+      "trace_variance": 0.18488027155399323,
+      "relative_variance": 0.22513595665361935,
+      "avg_sample_grad_norm": 0.9721819162368774,
+      "std_sample_grad_norm": 0.04711759110632938,
+      "avg_cosine_similarity_to_mean": 1.003186285495758
+    },
+    {
+      "mean_grad_norm": 0.8444343209266663,
+      "trace_variance": 0.1493278592824936,
+      "relative_variance": 0.2094156270354833,
+      "avg_sample_grad_norm": 0.9021681249141693,
+      "std_sample_grad_norm": 0.023769549794762847,
+      "avg_cosine_similarity_to_mean": 1.0020580887794495
+    },
+    {
+      "mean_grad_norm": 0.5821331143379211,
+      "trace_variance": 0.21182984113693237,
+      "relative_variance": 0.6250899711173901,
+      "avg_sample_grad_norm": 0.6914167404174805,
+      "std_sample_grad_norm": 0.07562904595760037,
+      "avg_cosine_similarity_to_mean": 0.9062196463346481
+    }
+  ],
+  "averaged": {
+    "mean_grad_norm": {
+      "mean": 0.7751749873161315,
+      "std": 0.11365286336587271
+    },
+    "trace_variance": {
+      "mean": 0.26683236956596373,
+      "std": 0.1800316149610794
+    },
+    "relative_variance": {
+      "mean": 0.4593948265334392,
+      "std": 0.27530580706159213
+    },
+    "avg_sample_grad_norm": {
+      "mean": 0.871255949139595,
+      "std": 0.11572298491365285
+    },
+    "std_sample_grad_norm": {
+      "mean": 0.11337855564530011,
+      "std": 0.11158080514754416
+    },
+    "avg_cosine_similarity_to_mean": {
+      "mean": 0.9542879968881607,
+      "std": 0.05135960519860018
+    }
+  }
+}

outputs/old/results_bs16_nr64_nb4_r5_blTrue.json

@@ -0,0 +1,80 @@
+{
+  "config": {
+    "batch_size": 16,
+    "rollout_num": 64,
+    "number_batches_per_round": 4,
+    "total_rounds": 5,
+    "model_path": "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/smollm2_0.3B_MaxRL_gsm8k_1000_steps",
+    "max_seq_len": 2048,
+    "seed": 42,
+    "baseline": true
+  },
+  "per_round": [
+    {
+      "mean_grad_norm": 0.2755725681781769,
+      "trace_variance": 0.13866141438484192,
+      "relative_variance": 1.8259280401992952,
+      "avg_sample_grad_norm": 0.38493604958057404,
+      "std_sample_grad_norm": 0.15309434629388827,
+      "avg_cosine_similarity_to_mean": 0.7401671260595322
+    },
+    {
+      "mean_grad_norm": 0.4243953227996826,
+      "trace_variance": 0.6096072793006897,
+      "relative_variance": 3.3846125939842477,
+      "avg_sample_grad_norm": 0.6765449717640877,
+      "std_sample_grad_norm": 0.3855063964765728,
+      "avg_cosine_similarity_to_mean": 0.5657118707895279
+    },
+    {
+      "mean_grad_norm": 0.27996593713760376,
+      "trace_variance": 0.16036519408226013,
+      "relative_variance": 2.0459721790598753,
+      "avg_sample_grad_norm": 0.4325138255953789,
+      "std_sample_grad_norm": 0.040878211355412856,
+      "avg_cosine_similarity_to_mean": 0.7004560381174088
+    },
+    {
+      "mean_grad_norm": 0.2685435116291046,
+      "trace_variance": 0.13540661334991455,
+      "relative_variance": 1.8776323020858432,
+      "avg_sample_grad_norm": 0.4076094403862953,
+      "std_sample_grad_norm": 0.01268766293214707,
+      "avg_cosine_similarity_to_mean": 0.7097402513027191
+    },
+    {
+      "mean_grad_norm": 0.23571749031543732,
+      "trace_variance": 0.1872667372226715,
+      "relative_variance": 3.370365696985525,
+      "avg_sample_grad_norm": 0.4250478520989418,
+      "std_sample_grad_norm": 0.06120551716417047,
+      "avg_cosine_similarity_to_mean": 0.6070868670940399
+    }
+  ],
+  "averaged": {
+    "mean_grad_norm": {
+      "mean": 0.29683896601200105,
+      "std": 0.06564152720226617
+    },
+    "trace_variance": {
+      "mean": 0.24626144766807556,
+      "std": 0.18261724839656943
+    },
+    "relative_variance": {
+      "mean": 2.5009021624629573,
+      "std": 0.719434171974512
+    },
+    "avg_sample_grad_norm": {
+      "mean": 0.4653304278850555,
+      "std": 0.10687017105313018
+    },
+    "std_sample_grad_norm": {
+      "mean": 0.13067442684443828,
+      "std": 0.1358323611821015
+    },
+    "avg_cosine_similarity_to_mean": {
+      "mean": 0.6646324306726455,
+      "std": 0.06651361604169471
+    }
+  }
+}

outputs/old/results_bs16_nr8_nb4_r5_blFalse.json

@@ -0,0 +1,80 @@
+{
+  "config": {
+    "batch_size": 16,
+    "rollout_num": 8,
+    "number_batches_per_round": 4,
+    "total_rounds": 5,
+    "model_path": "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/smollm2_0.3B_MaxRL_gsm8k_1000_steps",
+    "max_seq_len": 2048,
+    "seed": 42,
+    "baseline": false
+  },
+  "per_round": [
+    {
+      "mean_grad_norm": 0.7105476260185242,
+      "trace_variance": 0.4447573125362396,
+      "relative_variance": 0.880920489967786,
+      "avg_sample_grad_norm": 0.8949873298406601,
+      "std_sample_grad_norm": 0.08978978326506477,
+      "avg_cosine_similarity_to_mean": 0.8567404597997665
+    },
+    {
+      "mean_grad_norm": 0.7531298398971558,
+      "trace_variance": 0.5207900404930115,
+      "relative_variance": 0.91816970637431,
+      "avg_sample_grad_norm": 0.9467365890741348,
+      "std_sample_grad_norm": 0.1636269119236902,
+      "avg_cosine_similarity_to_mean": 0.8563707917928696
+    },
+    {
+      "mean_grad_norm": 0.6841264963150024,
+      "trace_variance": 0.3036300837993622,
+      "relative_variance": 0.6487419431051044,
+      "avg_sample_grad_norm": 0.8194261938333511,
+      "std_sample_grad_norm": 0.06866591628645671,
+      "avg_cosine_similarity_to_mean": 0.9007236510515213
+    },
+    {
+      "mean_grad_norm": 0.6350532174110413,
+      "trace_variance": 0.2895530164241791,
+      "relative_variance": 0.7179725695195097,
+      "avg_sample_grad_norm": 0.762009471654892,
+      "std_sample_grad_norm": 0.13810664175806275,
+      "avg_cosine_similarity_to_mean": 0.8990585058927536
+    },
+    {
+      "mean_grad_norm": 0.47783538699150085,
+      "trace_variance": 0.38107824325561523,
+      "relative_variance": 1.669004609419634,
+      "avg_sample_grad_norm": 0.6930959820747375,
+      "std_sample_grad_norm": 0.09961858263046741,
+      "avg_cosine_similarity_to_mean": 0.7430207431316376
+    }
+  ],
+  "averaged": {
+    "mean_grad_norm": {
+      "mean": 0.6521385133266449,
+      "std": 0.0951920067340915
+    },
+    "trace_variance": {
+      "mean": 0.38796173930168154,
+      "std": 0.08684766215895035
+    },
+    "relative_variance": {
+      "mean": 0.966961863677269,
+      "std": 0.3649403775708313
+    },
+    "avg_sample_grad_norm": {
+      "mean": 0.8232511132955551,
+      "std": 0.09066451825859152
+    },
+    "std_sample_grad_norm": {
+      "mean": 0.11196156717274837,
+      "std": 0.034267545660677176
+    },
+    "avg_cosine_similarity_to_mean": {
+      "mean": 0.8511828303337097,
+      "std": 0.05745121848128472
+    }
+  }
+}

outputs/old/results_bs16_nr8_nb4_r5_blTrue.json

@@ -0,0 +1,80 @@
+{
+  "config": {
+    "batch_size": 16,
+    "rollout_num": 8,
+    "number_batches_per_round": 4,
+    "total_rounds": 5,
+    "model_path": "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/smollm2_0.3B_MaxRL_gsm8k_1000_steps",
+    "max_seq_len": 2048,
+    "seed": 42,
+    "baseline": true
+  },
+  "per_round": [
+    {
+      "mean_grad_norm": 0.3068431317806244,
+      "trace_variance": 0.35510000586509705,
+      "relative_variance": 3.7715325967547115,
+      "avg_sample_grad_norm": 0.5735703259706497,
+      "std_sample_grad_norm": 0.09419738943035173,
+      "avg_cosine_similarity_to_mean": 0.5783642008900642
+    },
+    {
+      "mean_grad_norm": 0.2915055751800537,
+      "trace_variance": 0.35840773582458496,
+      "relative_variance": 4.217777287335315,
+      "avg_sample_grad_norm": 0.5577257871627808,
+      "std_sample_grad_norm": 0.13915088584464044,
+      "avg_cosine_similarity_to_mean": 0.5441212877631187
+    },
+    {
+      "mean_grad_norm": 0.21999073028564453,
+      "trace_variance": 0.2043260633945465,
+      "relative_variance": 4.2219686496831015,
+      "avg_sample_grad_norm": 0.4286266788840294,
+      "std_sample_grad_norm": 0.07468024966573314,
+      "avg_cosine_similarity_to_mean": 0.5293085053563118
+    },
+    {
+      "mean_grad_norm": 0.22899571061134338,
+      "trace_variance": 0.16267657279968262,
+      "relative_variance": 3.1022037496568386,
+      "avg_sample_grad_norm": 0.39560337364673615,
+      "std_sample_grad_norm": 0.08369558175357744,
+      "avg_cosine_similarity_to_mean": 0.6156094446778297
+    },
+    {
+      "mean_grad_norm": 0.29250001907348633,
+      "trace_variance": 0.3239949941635132,
+      "relative_variance": 3.7869232409130804,
+      "avg_sample_grad_norm": 0.5501251593232155,
+      "std_sample_grad_norm": 0.07720123505079711,
+      "avg_cosine_similarity_to_mean": 0.5774728059768677
+    }
+  ],
+  "averaged": {
+    "mean_grad_norm": {
+      "mean": 0.26796703338623046,
+      "std": 0.03602157970135398
+    },
+    "trace_variance": {
+      "mean": 0.28090107440948486,
+      "std": 0.08149922086187118
+    },
+    "relative_variance": {
+      "mean": 3.82008110486861,
+      "std": 0.4095070575542349
+    },
+    "avg_sample_grad_norm": {
+      "mean": 0.5011302649974823,
+      "std": 0.07381573007213547
+    },
+    "std_sample_grad_norm": {
+      "mean": 0.09378506834901998,
+      "std": 0.023664499864836274
+    },
+    "avg_cosine_similarity_to_mean": {
+      "mean": 0.5689752489328385,
+      "std": 0.030087469282562274
+    }
+  }
+}

plot_all_variance.py

@@ -0,0 +1,81 @@
+"""Plot variance analysis results for SmolLM (Math), Qwen3 (Math), Maze."""
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+OUTPUT_DIR = os.path.join(SCRIPT_DIR, "outputs")
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+# ── Data ──────────────────────────────────────────────────────────────────────
+rollout_nums = [4, 8, 16, 32, 64, 128]
+
+smollm_math = {
+    "blTrue":  [3.461569e-01, 3.488942e-01, 2.763410e-01, 2.600237e-01, 2.039304e-01, 1.596079e-01],
+    "blFalse": [5.613685e-01, 4.680250e-01, 3.457040e-01, 2.965937e-01, 2.275286e-01, 1.723276e-01],
+}
+
+qwen3_math = {
+    "blTrue":  [1.544762e-01, 1.679264e-01, 2.075920e-01, 1.788574e-01, 1.592376e-01, 1.314381e-01],
+    "blFalse": [2.140592e-01, 2.190761e-01, 2.448343e-01, 2.002312e-01, 1.702958e-01, 1.390878e-01],
+}
+
+maze = {
+    "blTrue":  [9.343412e-02, 7.531368e-02, 5.179188e-02, 4.027390e-02, 2.930888e-02, 2.354821e-02],
+    "blFalse": [1.171640e-01, 8.123477e-02, 5.614680e-02, 4.236686e-02, 3.015591e-02, 2.521931e-02],
+}
+
+datasets = [
+    ("SmolLM-360M (GSM8k)",        smollm_math),
+    ("Qwen3-1.7B (Polaris-53K)",   qwen3_math),
+    ("Qwen2-3M (Maze)",            maze),
+]
+
+# ── Style ─────────────────────────────────────────────────────────────────────
+plt.rcParams.update({
+    "font.size": 15,
+    "axes.titlesize": 18,
+    "axes.labelsize": 16,
+    "legend.fontsize": 14,
+    "xtick.labelsize": 14,
+    "ytick.labelsize": 14,
+    "figure.dpi": 150,
+    "savefig.dpi": 300,
+    "font.family": "sans-serif",
+})
+
+RED = "#D32F2F"
+AMBER = "#F9A825"
+
+# ── Plot ──────────────────────────────────────────────────────────────────────
+fig, axes = plt.subplots(1, 3, figsize=(21, 6))
+
+for ax, (title, data) in zip(axes, datasets):
+    xs = np.array(rollout_nums)
+    bl_true  = np.array([v if v is not None else np.nan for v in data["blTrue"]])
+    bl_false = np.array([v if v is not None else np.nan for v in data["blFalse"]])
+
+    ax.plot(xs, bl_true,  color=RED,   marker="*", markersize=18, linewidth=4,
+            label="MaxRL", zorder=5)
+    ax.plot(xs, bl_false, color=AMBER, marker="o", markersize=11, linewidth=4,
+            label="MaxRL (w/o baseline)", zorder=4)
+
+    ax.set_xscale("log", base=2)
+    ax.set_xticks(rollout_nums)
+    ax.set_xticklabels([str(n) for n in rollout_nums])
+    ax.set_xlabel("Number of Rollouts", fontsize=16)
+    ax.set_ylabel("Gradient Variance", fontsize=16)
+    ax.set_title(title, fontsize=18, fontweight="bold", pad=12)
+    ax.legend(loc="upper right", framealpha=0.9, edgecolor="gray")
+    ax.grid(True, alpha=0.3, linestyle="--")
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+
+plt.tight_layout(w_pad=3)
+out_path = os.path.join(OUTPUT_DIR, "variance_comparison_all.png")
+plt.savefig(out_path, bbox_inches="tight")
+plt.savefig(out_path.replace(".png", ".pdf"), bbox_inches="tight")
+print(f"Saved to {out_path}")

plot_variance.py

@@ -0,0 +1,39 @@
+import json
+import matplotlib.pyplot as plt
+import numpy as np
+
+rollout_nums = [4, 8, 16, 32, 64, 128]
+
+trace_var_bl_true = []
+trace_var_bl_false = []
+
+for nr in rollout_nums:
+    with open(f"results_bs16_nr{nr}_nb4_r5_blTrue.json") as f:
+        data = json.load(f)
+        trace_var_bl_true.append(data["averaged"]["trace_variance"]["mean"])
+
+    with open(f"results_bs16_nr{nr}_nb4_r5_blFalse.json") as f:
+        data = json.load(f)
+        trace_var_bl_false.append(data["averaged"]["trace_variance"]["mean"])
+
+fig, ax = plt.subplots(figsize=(7, 5))
+
+ax.plot(rollout_nums, trace_var_bl_true, marker='o', label='MaxRL')
+ax.plot(rollout_nums, trace_var_bl_false, marker='s', label='MaxRL (w/o baseline)')
+
+ax.set_xscale('log', base=2)
+ax.set_xticks(rollout_nums)
+ax.set_xticklabels(rollout_nums)
+ax.set_xlabel('Rollout', fontsize=14)
+ax.set_ylabel('Gradient Variance', fontsize=14)
+ax.legend(fontsize=12)
+ax.grid(True, alpha=0.3)
+
+plt.tight_layout()
+plt.savefig("variance_plot.pdf", dpi=300)
+plt.savefig("variance_plot.png", dpi=300)
+print("Saved variance_plot.pdf and variance_plot.png")
+
+print("\nData:")
+for nr, v_t, v_f in zip(rollout_nums, trace_var_bl_true, trace_var_bl_false):
+    print(f"  nr={nr}: blTrue={v_t:.4f}, blFalse={v_f:.4f}")

qwen3_variance_analysis_auto.py

@@ -0,0 +1,400 @@
+"""
+Automated Qwen3-1.7B Variance Analysis for MaxRL Policy Gradient.
+
+Runs all 12 experiments (6 rollout_nums x 2 baseline settings) across multiple
+GPUs with dynamic scheduling. Each GPU worker loads the model once and pulls
+experiments from a shared task pool. Saves only trace_covariance mean/std to
+outputs/ and plots the variance line chart.
+"""
+
+import json
+import os
+import random
+from functools import partial
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.multiprocessing as mp
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# ============================================================================
+# Configuration
+# ============================================================================
+BATCH_SIZE = 16
+ROLLOUT_NUMS = [4, 8, 16, 32, 64, 128]
+NUMBER_BATCHES_PER_ROUND = 4
+TOTAL_ROUNDS = 32
+MICRO_BATCH_SIZE = 2
+MAX_SEQ_LEN = 4096
+SEED = 42
+
+MODEL_PATH = "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/qwen3_1.7B_Base_MaxRL_Polaris_1000_steps"
+DATA_PATH = "/work/nvme/bgif/gzeng/MAXRL/variance_analysis/data/Qwen3/1.7b_512x512.jsonl"
+
+GPU_IDS = [0, 1, 2, 3]
+DTYPE = torch.bfloat16
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+OUTPUT_DIR = os.path.join(SCRIPT_DIR, "outputs", "Qwen3")
+
+
+# ============================================================================
+# Per-worker global state (initialized once per GPU worker)
+# ============================================================================
+_worker_model = None
+_worker_tokenizer = None
+_worker_prompt_data = None
+_worker_all_prompt_ids = None
+_worker_total_params = None
+_worker_device = None
+
+
+def worker_init(gpu_queue: mp.Queue):
+    """Called once per pool worker. Grabs a GPU and loads model + data."""
+    global _worker_model, _worker_tokenizer, _worker_prompt_data
+    global _worker_all_prompt_ids, _worker_total_params, _worker_device
+
+    gpu_id = gpu_queue.get()
+    _worker_device = f"cuda:{gpu_id}"
+    print(f"[Worker PID={os.getpid()}] Assigned to GPU {gpu_id}")
+
+    _worker_tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
+    if _worker_tokenizer.pad_token is None:
+        _worker_tokenizer.pad_token = _worker_tokenizer.eos_token
+
+    _worker_model = AutoModelForCausalLM.from_pretrained(
+        MODEL_PATH, torch_dtype=DTYPE,
+    ).to(_worker_device)
+    _worker_model.eval()
+    for p in _worker_model.parameters():
+        p.requires_grad_(True)
+
+    _worker_total_params = sum(p.numel() for p in _worker_model.parameters())
+    print(f"[GPU {gpu_id}] Model loaded: {_worker_total_params:,} parameters")
+
+    _worker_prompt_data = load_rollout_data(DATA_PATH)
+    _worker_all_prompt_ids = list(_worker_prompt_data.keys())
+
+
+# ============================================================================
+# Data Loading
+# ============================================================================
+def load_rollout_data(data_path: str) -> dict:
+    prompt_to_id = {}
+    prompt_data = {}
+
+    with open(data_path, "r") as f:
+        for line in f:
+            item = json.loads(line)
+            prompt_text = item["input"]
+            if prompt_text not in prompt_to_id:
+                pid = len(prompt_to_id)
+                prompt_to_id[prompt_text] = pid
+                prompt_data[pid] = {"input": prompt_text, "rollouts": []}
+            pid = prompt_to_id[prompt_text]
+            prompt_data[pid]["rollouts"].append({
+                "output": item["output"],
+                "score": item["score"],
+            })
+
+    print(f"Loaded {len(prompt_data)} prompts, "
+          f"each with {len(prompt_data[0]['rollouts'])} rollouts")
+    return prompt_data
+
+
+# ============================================================================
+# MaxRL Advantage Computation
+# ============================================================================
+def compute_maxrl_advantage(
+    scores: list[float], baseline: bool, epsilon: float = 1e-6,
+) -> list[float]:
+    mean = sum(scores) / len(scores)
+    if baseline:
+        return [(s - mean) / (mean + epsilon) for s in scores]
+    else:
+        return [s / (mean + epsilon) for s in scores]
+
+
+# ============================================================================
+# Tokenization & Batching
+# ============================================================================
+def tokenize_and_get_response_mask(
+    tokenizer, prompt: str, response: str, max_seq_len: int,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    prompt_ids = tokenizer.encode(prompt, add_special_tokens=False)
+    response_ids = tokenizer.encode(response, add_special_tokens=False)
+
+    total_len = len(prompt_ids) + len(response_ids)
+    if total_len > max_seq_len:
+        max_resp = max_seq_len - len(prompt_ids)
+        if max_resp <= 0:
+            prompt_ids = prompt_ids[:max_seq_len // 2]
+            max_resp = max_seq_len - len(prompt_ids)
+        response_ids = response_ids[:max_resp]
+
+    input_ids = prompt_ids + response_ids
+    response_mask = [0] * len(prompt_ids) + [1] * len(response_ids)
+
+    return (
+        torch.tensor(input_ids, dtype=torch.long),
+        torch.tensor(response_mask, dtype=torch.float32),
+    )
+
+
+def pad_batch(
+    batch_input_ids: list[torch.Tensor],
+    batch_response_masks: list[torch.Tensor],
+    pad_token_id: int,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    max_len = max(ids.shape[0] for ids in batch_input_ids)
+    B = len(batch_input_ids)
+
+    input_ids = torch.full((B, max_len), pad_token_id, dtype=torch.long)
+    response_mask = torch.zeros(B, max_len)
+    attention_mask = torch.zeros(B, max_len)
+
+    for i, (ids, rmask) in enumerate(zip(batch_input_ids, batch_response_masks)):
+        seq_len = ids.shape[0]
+        input_ids[i, max_len - seq_len:] = ids
+        response_mask[i, max_len - seq_len:] = rmask
+        attention_mask[i, max_len - seq_len:] = 1.0
+
+    return input_ids, response_mask, attention_mask
+
+
+# ============================================================================
+# Policy Gradient Loss
+# ============================================================================
+def compute_policy_gradient_loss(
+    model, input_ids, attention_mask, response_mask, advantages,
+) -> tuple[torch.Tensor, int]:
+    outputs = model(input_ids=input_ids, attention_mask=attention_mask)
+    logits = outputs.logits
+
+    shift_logits = logits[:, :-1, :]
+    shift_labels = input_ids[:, 1:]
+    shift_response_mask = response_mask[:, 1:]
+
+    log_probs = torch.log_softmax(shift_logits, dim=-1)
+    token_log_probs = torch.gather(
+        log_probs, dim=-1, index=shift_labels.unsqueeze(-1),
+    ).squeeze(-1)
+
+    token_losses = -advantages.unsqueeze(-1) * token_log_probs * shift_response_mask
+    valid_token_count = int(shift_response_mask.sum().item())
+    loss = token_losses.sum() / max(valid_token_count, 1)
+    return loss, valid_token_count
+
+
+# ============================================================================
+# Gradient Utilities
+# ============================================================================
+def collect_flat_gradient(model) -> torch.Tensor:
+    grads = []
+    for p in model.parameters():
+        if p.grad is not None:
+            grads.append(p.grad.detach().float().flatten())
+        else:
+            grads.append(torch.zeros(p.numel(), dtype=torch.float32, device=p.device))
+    return torch.cat(grads)
+
+
+def compute_trace_variance(
+    grad_sum: torch.Tensor, grad_sq_sum: torch.Tensor, K: int,
+) -> float:
+    grad_mean = grad_sum / K
+    elementwise_var = (grad_sq_sum / K - grad_mean ** 2) * (K / (K - 1))
+    return elementwise_var.sum().item()
+
+
+# ============================================================================
+# Single Experiment (runs inside a worker process)
+# ============================================================================
+def run_single_experiment(task: tuple[int, bool]) -> tuple[str, dict]:
+    """Run one experiment using the worker's pre-loaded model and data.
+
+    Args:
+        task: (rollout_num, baseline)
+
+    Returns:
+        (key, {"mean": float, "std": float})
+    """
+    rollout_num, baseline = task
+    key = f"nr{rollout_num}_bl{baseline}"
+
+    model = _worker_model
+    tokenizer = _worker_tokenizer
+    prompt_data = _worker_prompt_data
+    all_prompt_ids = _worker_all_prompt_ids
+    total_params = _worker_total_params
+    device = _worker_device
+
+    print(f"[{device}] Starting {key}")
+
+    random.seed(SEED)
+    np.random.seed(SEED)
+    torch.manual_seed(SEED)
+
+    trace_variances = []
+
+    for round_idx in range(TOTAL_ROUNDS):
+        sampled_prompts = random.sample(all_prompt_ids, BATCH_SIZE)
+
+        rollouts_needed = NUMBER_BATCHES_PER_ROUND * rollout_num
+        round_rollout_subsets = {}
+        for pid in sampled_prompts:
+            rollouts = prompt_data[pid]["rollouts"]
+            if len(rollouts) < rollouts_needed:
+                raise ValueError(
+                    f"Prompt {pid} has {len(rollouts)} rollouts, need {rollouts_needed}"
+                )
+            sampled = random.sample(rollouts, rollouts_needed)
+            round_rollout_subsets[pid] = [
+                sampled[s:s + rollout_num]
+                for s in range(0, rollouts_needed, rollout_num)
+            ]
+
+        grad_sum = torch.zeros(total_params, dtype=torch.float32)
+        grad_sq_sum = torch.zeros(total_params, dtype=torch.float32)
+
+        for subset_idx in range(NUMBER_BATCHES_PER_ROUND):
+            all_input_ids = []
+            all_response_masks = []
+            all_advantages = []
+
+            for pid in sampled_prompts:
+                prompt_text = prompt_data[pid]["input"]
+                sampled_rollouts = round_rollout_subsets[pid][subset_idx]
+                scores = [r["score"] for r in sampled_rollouts]
+                advantages = compute_maxrl_advantage(scores, baseline)
+
+                for rollout, adv in zip(sampled_rollouts, advantages):
+                    ids, rmask = tokenize_and_get_response_mask(
+                        tokenizer, prompt_text, rollout["output"], MAX_SEQ_LEN,
+                    )
+                    all_input_ids.append(ids)
+                    all_response_masks.append(rmask)
+                    all_advantages.append(adv)
+
+            model.zero_grad()
+            total_valid_tokens = int(
+                sum(rmask[1:].sum().item() for rmask in all_response_masks)
+            )
+            num_samples = len(all_input_ids)
+
+            for mb_start in range(0, num_samples, MICRO_BATCH_SIZE):
+                mb_end = min(mb_start + MICRO_BATCH_SIZE, num_samples)
+
+                mb_ids = all_input_ids[mb_start:mb_end]
+                mb_masks = all_response_masks[mb_start:mb_end]
+                mb_advs = all_advantages[mb_start:mb_end]
+
+                input_ids, response_mask, attention_mask = pad_batch(
+                    mb_ids, mb_masks, tokenizer.pad_token_id,
+                )
+                input_ids = input_ids.to(device)
+                response_mask = response_mask.to(device)
+                attention_mask = attention_mask.to(device)
+                advantages_t = torch.tensor(mb_advs, dtype=DTYPE, device=device)
+
+                mb_loss, mb_valid_tokens = compute_policy_gradient_loss(
+                    model, input_ids, attention_mask, response_mask, advantages_t,
+                )
+                scaled_loss = mb_loss * (mb_valid_tokens / max(total_valid_tokens, 1))
+                scaled_loss.backward()
+
+            flat_grad = collect_flat_gradient(model).cpu()
+            grad_sum += flat_grad
+            grad_sq_sum += flat_grad ** 2
+
+        trace_var = compute_trace_variance(
+            grad_sum, grad_sq_sum, NUMBER_BATCHES_PER_ROUND,
+        )
+        trace_variances.append(trace_var)
+        print(f"  [{device}] {key} round {round_idx+1}/{TOTAL_ROUNDS}: "
+              f"trace_cov={trace_var:.6e}")
+
+    result = {
+        "mean": float(np.mean(trace_variances)),
+        "std": float(np.std(trace_variances)),
+    }
+    print(f"[{device}] Finished {key}: mean={result['mean']:.6e}, std={result['std']:.6e}")
+    return key, result
+
+
+# ============================================================================
+# Plotting
+# ============================================================================
+def plot_results(results: dict, output_dir: str):
+    rollout_nums = ROLLOUT_NUMS
+
+    means_bl_true = [results[f"nr{nr}_blTrue"]["mean"] for nr in rollout_nums]
+    means_bl_false = [results[f"nr{nr}_blFalse"]["mean"] for nr in rollout_nums]
+
+    fig, ax = plt.subplots(figsize=(7, 5))
+
+    ax.plot(rollout_nums, means_bl_true, marker='o', label='MaxRL')
+    ax.plot(rollout_nums, means_bl_false, marker='s', label='MaxRL (w/o baseline)')
+
+    ax.set_xscale('log', base=2)
+    ax.set_xticks(rollout_nums)
+    ax.set_xticklabels(rollout_nums)
+    ax.set_xlabel('Rollout', fontsize=14)
+    ax.set_ylabel('Gradient Variance', fontsize=14)
+    ax.legend(fontsize=12)
+    ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    plt.savefig(os.path.join(output_dir, "variance_plot.pdf"), dpi=300)
+    plt.savefig(os.path.join(output_dir, "variance_plot.png"), dpi=300)
+    print(f"Plots saved to {output_dir}/variance_plot.{{pdf,png}}")
+
+
+# ============================================================================
+# Main
+# ============================================================================
+def main():
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    # Build task list: 12 experiments
+    tasks = []
+    for rollout_num in ROLLOUT_NUMS:
+        for baseline in [True, False]:
+            tasks.append((rollout_num, baseline))
+
+    print(f"Scheduling {len(tasks)} experiments across {len(GPU_IDS)} GPUs")
+
+    # GPU queue: each worker grabs one GPU ID on init
+    gpu_queue = mp.Queue()
+    for gid in GPU_IDS:
+        gpu_queue.put(gid)
+
+    # Pool of workers = number of GPUs. Each worker inits once (loads model),
+    # then processes tasks dynamically from the pool.
+    with mp.Pool(
+        processes=len(GPU_IDS),
+        initializer=worker_init,
+        initargs=(gpu_queue,),
+    ) as pool:
+        results_list = pool.map(run_single_experiment, tasks)
+
+    # Collect results
+    results = dict(results_list)
+
+    # Save
+    results_path = os.path.join(OUTPUT_DIR, "results.json")
+    with open(results_path, "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"Results saved to {results_path}")
+
+    # Plot
+    plot_results(results, OUTPUT_DIR)
+    print("All done!")
+
+
+if __name__ == "__main__":
+    mp.set_start_method("spawn")
+    main()

qwen3_variance_analysis_resume.py

@@ -0,0 +1,75 @@
+"""
+Resume script for Qwen3 variance analysis.
+Only runs the 2 experiments interrupted by job 2033368:
+  nr128_blTrue, nr128_blFalse
+Then merges with the 10 completed results from the killed run and saves/plots.
+"""
+
+import json
+import os
+import sys
+
+# Reuse everything from the original script
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from qwen3_variance_analysis_auto import (
+    ROLLOUT_NUMS, OUTPUT_DIR,
+    worker_init, run_single_experiment, plot_results,
+)
+import torch.multiprocessing as mp
+
+
+# Results already completed in job 2033368 (extracted from log)
+COMPLETED_RESULTS = {
+    "nr4_blFalse":  {"mean": 2.453292e-01, "std": 8.433693e-02},
+    "nr4_blTrue":   {"mean": 1.544762e-01, "std": 5.542017e-02},
+    "nr8_blTrue":   {"mean": 1.679264e-01, "std": 5.820824e-02},
+    "nr8_blFalse":  {"mean": 2.190761e-01, "std": 7.012213e-02},
+    "nr16_blFalse": {"mean": 2.448343e-01, "std": 7.550860e-02},
+    "nr16_blTrue":  {"mean": 2.075920e-01, "std": 6.842490e-02},
+    "nr32_blTrue":  {"mean": 1.788574e-01, "std": 5.623576e-02},
+    "nr32_blFalse": {"mean": 2.002312e-01, "std": 5.805813e-02},
+    "nr64_blFalse": {"mean": 1.702958e-01, "std": 5.899355e-02},
+    "nr64_blTrue":  {"mean": 1.592376e-01, "std": 5.725100e-02},
+}
+
+# Only need to run these 2
+REMAINING_TASKS = [
+    (128, True),   # nr128_blTrue
+    (128, False),  # nr128_blFalse
+]
+
+
+def main():
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    print(f"Resuming: {len(REMAINING_TASKS)} experiments on 2 GPUs")
+
+    gpu_queue = mp.Queue()
+    for gid in [0, 1]:
+        gpu_queue.put(gid)
+
+    with mp.Pool(
+        processes=2,
+        initializer=worker_init,
+        initargs=(gpu_queue,),
+    ) as pool:
+        new_results_list = pool.map(run_single_experiment, REMAINING_TASKS)
+
+    # Merge
+    results = dict(COMPLETED_RESULTS)
+    results.update(dict(new_results_list))
+
+    # Save
+    results_path = os.path.join(OUTPUT_DIR, "results.json")
+    with open(results_path, "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"Results saved to {results_path}")
+
+    # Plot
+    plot_results(results, OUTPUT_DIR)
+    print("All done!")
+
+
+if __name__ == "__main__":
+    mp.set_start_method("spawn")
+    main()

run_maze_auto.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+#SBATCH --job-name=var_maze
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=1
+#SBATCH --cpus-per-task=64
+#SBATCH --gres=gpu:4
+#SBATCH --time=24:00:00
+#SBATCH --mem=256G
+#SBATCH --output=logs/%x_%j.log
+#SBATCH --partition=ghx4
+#SBATCH --account=bgif-dtai-gh
+#SBATCH --reservation=sup-24244
+
+source /u/gzeng/.bashrc >/dev/null 2>&1 || true
+source /u/gzeng/miniconda3/etc/profile.d/conda.sh
+conda activate exploration
+
+set -Eeuo pipefail
+
+export CACHE="/work/nvme/bgif/gzeng/MAXRL/cache"
+export HF_HOME="${CACHE}/huggingface"
+export HUGGINGFACE_HUB_CACHE="${HF_HOME}/hub"
+unset TRANSFORMERS_CACHE
+
+export PYTHONUNBUFFERED=1
+export NCCL_DEBUG=WARN
+export TOKENIZERS_PARALLELISM=false
+
+mkdir -p logs
+
+echo "Start: $(date -Ins)"
+echo "Node: $(hostname)"
+echo "GPUs: $(nvidia-smi -L 2>/dev/null | wc -l)"
+
+cd /work/nvme/bgif/gzeng/MAXRL/variance_analysis
+python maze_variance_analysis_auto.py
+
+echo "Done: $(date -Ins)"

run_qwen3_auto.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+#SBATCH --job-name=var_qwen3
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=1
+#SBATCH --cpus-per-task=64
+#SBATCH --gres=gpu:4
+#SBATCH --time=48:00:00
+#SBATCH --mem=256G
+#SBATCH --output=logs/%x_%j.log
+#SBATCH --partition=ghx4
+#SBATCH --account=bgif-dtai-gh
+#SBATCH --reservation=sup-24244
+
+source /u/gzeng/.bashrc >/dev/null 2>&1 || true
+source /u/gzeng/miniconda3/etc/profile.d/conda.sh
+conda activate exploration
+
+set -Eeuo pipefail
+
+export CACHE="/work/nvme/bgif/gzeng/MAXRL/cache"
+export HF_HOME="${CACHE}/huggingface"
+export HUGGINGFACE_HUB_CACHE="${HF_HOME}/hub"
+unset TRANSFORMERS_CACHE
+
+export PYTHONUNBUFFERED=1
+export NCCL_DEBUG=WARN
+export TOKENIZERS_PARALLELISM=false
+
+mkdir -p logs
+
+echo "Start: $(date -Ins)"
+echo "Node: $(hostname)"
+echo "GPUs: $(nvidia-smi -L 2>/dev/null | wc -l)"
+
+cd /work/nvme/bgif/gzeng/MAXRL/variance_analysis
+python qwen3_variance_analysis_auto.py
+
+echo "Done: $(date -Ins)"

run_qwen3_resume.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+#SBATCH --job-name=var_qwen3_resume
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=1
+#SBATCH --cpus-per-task=128
+#SBATCH --gres=gpu:4
+#SBATCH --time=12:00:00
+#SBATCH --mem=512G
+#SBATCH --output=logs/%x_%j.log
+#SBATCH --partition=ghx4
+#SBATCH --account=bgif-dtai-gh
+#SBATCH --reservation=sup-24244
+
+source /u/gzeng/.bashrc >/dev/null 2>&1 || true
+source /u/gzeng/miniconda3/etc/profile.d/conda.sh
+conda activate exploration
+
+set -Eeuo pipefail
+
+export CACHE="/work/nvme/bgif/gzeng/MAXRL/cache"
+export HF_HOME="${CACHE}/huggingface"
+export HUGGINGFACE_HUB_CACHE="${HF_HOME}/hub"
+unset TRANSFORMERS_CACHE
+
+export PYTHONUNBUFFERED=1
+export NCCL_DEBUG=WARN
+export TOKENIZERS_PARALLELISM=false
+
+mkdir -p logs
+
+echo "Start: $(date -Ins)"
+echo "Node: $(hostname)"
+echo "GPUs: $(nvidia-smi -L 2>/dev/null | wc -l)"
+
+cd /work/nvme/bgif/gzeng/MAXRL/variance_analysis
+python qwen3_variance_analysis_resume.py
+
+echo "Done: $(date -Ins)"

run_smollm_auto.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+#SBATCH --job-name=var_smollm
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=1
+#SBATCH --cpus-per-task=64
+#SBATCH --gres=gpu:4
+#SBATCH --time=24:00:00
+#SBATCH --mem=256G
+#SBATCH --output=logs/%x_%j.log
+#SBATCH --partition=ghx4
+#SBATCH --account=bgif-dtai-gh
+#SBATCH --reservation=sup-24244
+
+source /u/gzeng/.bashrc >/dev/null 2>&1 || true
+source /u/gzeng/miniconda3/etc/profile.d/conda.sh
+conda activate exploration
+
+set -Eeuo pipefail
+
+export CACHE="/work/nvme/bgif/gzeng/MAXRL/cache"
+export HF_HOME="${CACHE}/huggingface"
+export HUGGINGFACE_HUB_CACHE="${HF_HOME}/hub"
+unset TRANSFORMERS_CACHE
+
+export PYTHONUNBUFFERED=1
+export NCCL_DEBUG=WARN
+export TOKENIZERS_PARALLELISM=false
+
+mkdir -p logs
+
+echo "Start: $(date -Ins)"
+echo "Node: $(hostname)"
+echo "GPUs: $(nvidia-smi -L 2>/dev/null | wc -l)"
+
+cd /work/nvme/bgif/gzeng/MAXRL/variance_analysis
+python smollm_variance_analysis_auto.py
+
+echo "Done: $(date -Ins)"

run_smollm_snr.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+#SBATCH --job-name=snr_smollm
+#SBATCH --nodes=1
+#SBATCH --ntasks-per-node=1
+#SBATCH --cpus-per-task=64
+#SBATCH --gres=gpu:4
+#SBATCH --time=24:00:00
+#SBATCH --mem=256G
+#SBATCH --output=logs/%x_%j.log
+#SBATCH --partition=ghx4
+#SBATCH --account=bgif-dtai-gh
+#SBATCH --reservation=sup-24244
+
+source /u/gzeng/.bashrc >/dev/null 2>&1 || true
+source /u/gzeng/miniconda3/etc/profile.d/conda.sh
+conda activate exploration
+
+set -Eeuo pipefail
+
+export CACHE="/work/nvme/bgif/gzeng/MAXRL/cache"
+export HF_HOME="${CACHE}/huggingface"
+export HUGGINGFACE_HUB_CACHE="${HF_HOME}/hub"
+unset TRANSFORMERS_CACHE
+
+export PYTHONUNBUFFERED=1
+export NCCL_DEBUG=WARN
+export TOKENIZERS_PARALLELISM=false
+
+mkdir -p logs
+
+echo "Start: $(date -Ins)"
+echo "Node: $(hostname)"
+echo "GPUs: $(nvidia-smi -L 2>/dev/null | wc -l)"
+
+cd /work/nvme/bgif/gzeng/MAXRL/variance_analysis
+python smollm_snr_analysis_auto.py
+
+echo "Done: $(date -Ins)"

smollm_snr_analysis_auto.py

@@ -0,0 +1,442 @@
+"""
+SmolLM Gradient SNR Analysis (Daman-style).
+
+For a FIXED batch of 64 prompts, compute S=64 gradient samples per
+(advantage_type, rollout_num) pair.  Each gradient sample re-samples rollouts
+from the pre-computed pool, so the only source of variance is rollout sampling.
+
+Reports SNR = ||mean(grad)||^2 / sum(var(grad))  for MaxRL, GRPO, and RLOO.
+Distributes experiments across GPUs with dynamic scheduling.
+"""
+
+import json
+import os
+import random
+from functools import partial
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.multiprocessing as mp
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# ============================================================================
+# Configuration
+# ============================================================================
+BATCH_SIZE = 64          # fixed first 64 prompts
+ROLLOUT_NUMS = [4, 8]
+S = 64                   # number of gradient samples for SNR estimation
+MICRO_BATCH_SIZE = 8
+MAX_SEQ_LEN = 2048
+SEED = 42
+
+ADVANTAGE_TYPES = ["maxrl", "grpo", "rloo"]
+
+MODEL_PATH = "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/smollm2_0.3B_MaxRL_gsm8k_1000_steps"
+DATA_PATH = "/work/nvme/bgif/gzeng/MAXRL/variance_analysis/data/SmolLM/512x512.jsonl"
+
+GPU_IDS = [0, 1, 2, 3]
+DTYPE = torch.bfloat16
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+OUTPUT_DIR = os.path.join(SCRIPT_DIR, "outputs", "SmolLM_SNR")
+
+# ============================================================================
+# Per-worker global state
+# ============================================================================
+_worker_model = None
+_worker_tokenizer = None
+_worker_prompt_data = None
+_worker_fixed_prompt_ids = None
+_worker_total_params = None
+_worker_device = None
+
+
+def worker_init(gpu_queue: mp.Queue):
+    global _worker_model, _worker_tokenizer, _worker_prompt_data
+    global _worker_fixed_prompt_ids, _worker_total_params, _worker_device
+
+    gpu_id = gpu_queue.get()
+    _worker_device = f"cuda:{gpu_id}"
+    print(f"[Worker PID={os.getpid()}] Assigned to GPU {gpu_id}")
+
+    _worker_tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
+    if _worker_tokenizer.pad_token is None:
+        _worker_tokenizer.pad_token = _worker_tokenizer.eos_token
+
+    _worker_model = AutoModelForCausalLM.from_pretrained(
+        MODEL_PATH, torch_dtype=DTYPE,
+    ).to(_worker_device)
+    _worker_model.eval()
+    for p in _worker_model.parameters():
+        p.requires_grad_(True)
+
+    _worker_total_params = sum(p.numel() for p in _worker_model.parameters())
+    print(f"[GPU {gpu_id}] Model loaded: {_worker_total_params:,} parameters")
+
+    _worker_prompt_data = load_rollout_data(DATA_PATH)
+    # Fix the first BATCH_SIZE prompts
+    _worker_fixed_prompt_ids = list(range(BATCH_SIZE))
+
+
+# ============================================================================
+# Data Loading
+# ============================================================================
+def load_rollout_data(data_path: str) -> dict:
+    prompt_to_id = {}
+    prompt_data = {}
+
+    with open(data_path, "r") as f:
+        for line in f:
+            item = json.loads(line)
+            prompt_text = item["input"]
+            if prompt_text not in prompt_to_id:
+                pid = len(prompt_to_id)
+                prompt_to_id[prompt_text] = pid
+                prompt_data[pid] = {"input": prompt_text, "rollouts": []}
+            pid = prompt_to_id[prompt_text]
+            prompt_data[pid]["rollouts"].append({
+                "output": item["output"],
+                "score": item["score"],
+            })
+
+    print(f"Loaded {len(prompt_data)} prompts, "
+          f"each with {len(prompt_data[0]['rollouts'])} rollouts")
+    return prompt_data
+
+
+# ============================================================================
+# Advantage Computation
+# ============================================================================
+def compute_advantage(scores: list[float], advantage_type: str, epsilon: float = 1e-6) -> list[float]:
+    n = len(scores)
+    mean = sum(scores) / n
+
+    if advantage_type == "maxrl":
+        # (score - mean) / (mean + eps)
+        return [(s - mean) / (mean + epsilon) for s in scores]
+
+    elif advantage_type == "grpo":
+        # (score - mean) / (std + eps)
+        var = sum((s - mean) ** 2 for s in scores) / n
+        std = var ** 0.5
+        return [(s - mean) / (std + epsilon) for s in scores]
+
+    elif advantage_type == "rloo":
+        # REINFORCE Leave-One-Out: advantage_i = score_i - mean_{j != i}
+        total = sum(scores)
+        return [s - (total - s) / (n - 1) for s in scores]
+
+    else:
+        raise ValueError(f"Unknown advantage type: {advantage_type}")
+
+
+# ============================================================================
+# Tokenization & Batching
+# ============================================================================
+def tokenize_and_get_response_mask(
+    tokenizer, prompt: str, response: str, max_seq_len: int,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    prompt_ids = tokenizer.encode(prompt, add_special_tokens=False)
+    response_ids = tokenizer.encode(response, add_special_tokens=False)
+
+    total_len = len(prompt_ids) + len(response_ids)
+    if total_len > max_seq_len:
+        max_resp = max_seq_len - len(prompt_ids)
+        if max_resp <= 0:
+            prompt_ids = prompt_ids[:max_seq_len // 2]
+            max_resp = max_seq_len - len(prompt_ids)
+        response_ids = response_ids[:max_resp]
+
+    input_ids = prompt_ids + response_ids
+    response_mask = [0] * len(prompt_ids) + [1] * len(response_ids)
+
+    return (
+        torch.tensor(input_ids, dtype=torch.long),
+        torch.tensor(response_mask, dtype=torch.float32),
+    )
+
+
+def pad_batch(
+    batch_input_ids: list[torch.Tensor],
+    batch_response_masks: list[torch.Tensor],
+    pad_token_id: int,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    max_len = max(ids.shape[0] for ids in batch_input_ids)
+    B = len(batch_input_ids)
+
+    input_ids = torch.full((B, max_len), pad_token_id, dtype=torch.long)
+    response_mask = torch.zeros(B, max_len)
+    attention_mask = torch.zeros(B, max_len)
+
+    for i, (ids, rmask) in enumerate(zip(batch_input_ids, batch_response_masks)):
+        seq_len = ids.shape[0]
+        input_ids[i, max_len - seq_len:] = ids
+        response_mask[i, max_len - seq_len:] = rmask
+        attention_mask[i, max_len - seq_len:] = 1.0
+
+    return input_ids, response_mask, attention_mask
+
+
+# ============================================================================
+# Policy Gradient Loss
+# ============================================================================
+def compute_policy_gradient_loss(
+    model, input_ids, attention_mask, response_mask, advantages,
+) -> tuple[torch.Tensor, int]:
+    outputs = model(input_ids=input_ids, attention_mask=attention_mask)
+    logits = outputs.logits
+
+    shift_logits = logits[:, :-1, :]
+    shift_labels = input_ids[:, 1:]
+    shift_response_mask = response_mask[:, 1:]
+
+    log_probs = torch.log_softmax(shift_logits, dim=-1)
+    token_log_probs = torch.gather(
+        log_probs, dim=-1, index=shift_labels.unsqueeze(-1),
+    ).squeeze(-1)
+
+    token_losses = -advantages.unsqueeze(-1) * token_log_probs * shift_response_mask
+    valid_token_count = int(shift_response_mask.sum().item())
+    loss = token_losses.sum() / max(valid_token_count, 1)
+    return loss, valid_token_count
+
+
+# ============================================================================
+# Gradient Utilities
+# ============================================================================
+def collect_flat_gradient(model) -> torch.Tensor:
+    grads = []
+    for p in model.parameters():
+        if p.grad is not None:
+            grads.append(p.grad.detach().float().flatten())
+        else:
+            grads.append(torch.zeros(p.numel(), dtype=torch.float32, device=p.device))
+    return torch.cat(grads)
+
+
+def gradient_snr(gradients: torch.Tensor, eps: float = 1e-8):
+    """
+    Compute gradient SNR from (S, D) tensor of gradient vectors.
+    Returns: (snr, mean_sq_norm, var_sum)
+    """
+    mu = gradients.mean(dim=0)
+    var = gradients.var(dim=0, unbiased=False)
+    mean_sq_norm = mu.pow(2).sum()
+    var_sum = var.sum()
+    snr = mean_sq_norm / (var_sum + eps)
+    return snr.item(), mean_sq_norm.item(), var_sum.item()
+
+
+# ============================================================================
+# Single Experiment
+# ============================================================================
+def run_single_experiment(task: tuple[str, int]) -> tuple[str, dict]:
+    advantage_type, rollout_num = task
+    key = f"{advantage_type}_nr{rollout_num}"
+
+    model = _worker_model
+    tokenizer = _worker_tokenizer
+    prompt_data = _worker_prompt_data
+    fixed_prompt_ids = _worker_fixed_prompt_ids
+    device = _worker_device
+
+    print(f"[{device}] Starting {key}")
+
+    all_grads = []
+
+    for s in range(S):
+        random.seed(SEED + s)
+
+        # For each prompt, sample rollout_num rollouts from the pool
+        all_input_ids = []
+        all_response_masks = []
+        all_advantages = []
+
+        for pid in fixed_prompt_ids:
+            rollouts = prompt_data[pid]["rollouts"]
+            sampled = random.sample(rollouts, rollout_num)
+            scores = [r["score"] for r in sampled]
+            advantages = compute_advantage(scores, advantage_type)
+
+            for rollout, adv in zip(sampled, advantages):
+                ids, rmask = tokenize_and_get_response_mask(
+                    tokenizer, prompt_data[pid]["input"], rollout["output"], MAX_SEQ_LEN,
+                )
+                all_input_ids.append(ids)
+                all_response_masks.append(rmask)
+                all_advantages.append(adv)
+
+        # Forward + backward with micro-batching
+        model.zero_grad()
+        total_valid_tokens = int(
+            sum(rmask[1:].sum().item() for rmask in all_response_masks)
+        )
+        num_samples = len(all_input_ids)
+
+        for mb_start in range(0, num_samples, MICRO_BATCH_SIZE):
+            mb_end = min(mb_start + MICRO_BATCH_SIZE, num_samples)
+
+            mb_ids = all_input_ids[mb_start:mb_end]
+            mb_masks = all_response_masks[mb_start:mb_end]
+            mb_advs = all_advantages[mb_start:mb_end]
+
+            input_ids, response_mask, attention_mask = pad_batch(
+                mb_ids, mb_masks, tokenizer.pad_token_id,
+            )
+            input_ids = input_ids.to(device)
+            response_mask = response_mask.to(device)
+            attention_mask = attention_mask.to(device)
+            advantages_t = torch.tensor(mb_advs, dtype=DTYPE, device=device)
+
+            mb_loss, mb_valid_tokens = compute_policy_gradient_loss(
+                model, input_ids, attention_mask, response_mask, advantages_t,
+            )
+            scaled_loss = mb_loss * (mb_valid_tokens / max(total_valid_tokens, 1))
+            scaled_loss.backward()
+
+        flat_grad = collect_flat_gradient(model).cpu()
+        all_grads.append(flat_grad)
+
+        if (s + 1) % 16 == 0:
+            print(f"  [{device}] {key}: {s+1}/{S} gradient samples collected")
+
+    gradients = torch.stack(all_grads)  # (S, D)
+    snr, mean_sq_norm, var_sum = gradient_snr(gradients)
+    print(f"[{device}] {key}: SNR={snr:.6f}, mean={mean_sq_norm:.6e}, var={var_sum:.6e}")
+
+    result = {
+        "snr": snr,
+        "mean": mean_sq_norm,
+        "var": var_sum,
+    }
+    return key, result
+
+
+# ============================================================================
+# Plotting
+# ============================================================================
+LABEL_MAP = {
+    "maxrl": "MaxRL",
+    "grpo":  "GRPO",
+    "rloo":  "RLOO",
+}
+
+COLOR_MAP = {
+    "maxrl": "#e74c3c",
+    "grpo":  "#3498db",
+    "rloo":  "#2ecc71",
+}
+
+
+def plot_results(results: dict, output_dir: str):
+    fig, axes = plt.subplots(1, 3, figsize=(18, 5))
+
+    # --- SNR ---
+    ax = axes[0]
+    for adv_type in ADVANTAGE_TYPES:
+        xs, ys = [], []
+        for nr in ROLLOUT_NUMS:
+            key = f"{adv_type}_nr{nr}"
+            if key in results and results[key] is not None:
+                xs.append(nr)
+                ys.append(results[key]["snr"])
+        label = LABEL_MAP.get(adv_type, adv_type)
+        ax.plot(xs, ys, marker="o", label=label, color=COLOR_MAP.get(adv_type))
+    ax.set_xscale("log", base=2)
+    ax.set_xticks(ROLLOUT_NUMS)
+    ax.set_xticklabels(ROLLOUT_NUMS)
+    ax.set_xlabel("Rollouts (N)")
+    ax.set_ylabel("Gradient SNR")
+    ax.set_title(f"Gradient SNR  (S={S}, batch={BATCH_SIZE})")
+    ax.legend()
+    ax.grid(True, which="both", linestyle="--", alpha=0.5)
+
+    # --- Mean (signal) ---
+    ax = axes[1]
+    for adv_type in ADVANTAGE_TYPES:
+        xs, ys = [], []
+        for nr in ROLLOUT_NUMS:
+            key = f"{adv_type}_nr{nr}"
+            if key in results and results[key] is not None:
+                xs.append(nr)
+                ys.append(results[key]["mean"])
+        label = LABEL_MAP.get(adv_type, adv_type)
+        ax.plot(xs, ys, marker="o", label=label, color=COLOR_MAP.get(adv_type))
+    ax.set_xscale("log", base=2)
+    ax.set_xticks(ROLLOUT_NUMS)
+    ax.set_xticklabels(ROLLOUT_NUMS)
+    ax.set_xlabel("Rollouts (N)")
+    ax.set_ylabel("||mean(grad)||²")
+    ax.set_title("Signal (mean gradient norm²)")
+    ax.legend()
+    ax.grid(True, which="both", linestyle="--", alpha=0.5)
+
+    # --- Var (noise) ---
+    ax = axes[2]
+    for adv_type in ADVANTAGE_TYPES:
+        xs, ys = [], []
+        for nr in ROLLOUT_NUMS:
+            key = f"{adv_type}_nr{nr}"
+            if key in results and results[key] is not None:
+                xs.append(nr)
+                ys.append(results[key]["var"])
+        label = LABEL_MAP.get(adv_type, adv_type)
+        ax.plot(xs, ys, marker="o", label=label, color=COLOR_MAP.get(adv_type))
+    ax.set_xscale("log", base=2)
+    ax.set_xticks(ROLLOUT_NUMS)
+    ax.set_xticklabels(ROLLOUT_NUMS)
+    ax.set_xlabel("Rollouts (N)")
+    ax.set_ylabel("sum(var(grad))")
+    ax.set_title("Noise (gradient variance)")
+    ax.legend()
+    ax.grid(True, which="both", linestyle="--", alpha=0.5)
+
+    plt.tight_layout()
+    plt.savefig(os.path.join(output_dir, "snr_plot.pdf"), dpi=300)
+    plt.savefig(os.path.join(output_dir, "snr_plot.png"), dpi=300)
+    print(f"Plots saved to {output_dir}/snr_plot.{{pdf,png}}")
+
+
+# ============================================================================
+# Main
+# ============================================================================
+def main():
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    # Build task list: 3 advantage types x 6 rollout nums = 18 experiments
+    tasks = []
+    for adv_type in ADVANTAGE_TYPES:
+        for rollout_num in ROLLOUT_NUMS:
+            tasks.append((adv_type, rollout_num))
+
+    print(f"Scheduling {len(tasks)} experiments across {len(GPU_IDS)} GPUs")
+    print(f"Fixed batch: first {BATCH_SIZE} prompts, S={S} gradient samples each")
+
+    gpu_queue = mp.Queue()
+    for gid in GPU_IDS:
+        gpu_queue.put(gid)
+
+    with mp.Pool(
+        processes=len(GPU_IDS),
+        initializer=worker_init,
+        initargs=(gpu_queue,),
+    ) as pool:
+        results_list = pool.map(run_single_experiment, tasks)
+
+    results = dict(results_list)
+
+    results_path = os.path.join(OUTPUT_DIR, "snr_results.json")
+    with open(results_path, "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"Results saved to {results_path}")
+
+    plot_results(results, OUTPUT_DIR)
+    print("All done!")
+
+
+if __name__ == "__main__":
+    mp.set_start_method("spawn")
+    main()

smollm_variance_analysis.py

@@ -0,0 +1,478 @@
+"""
+SmolLM Variance Analysis for MaxRL Policy Gradient.
+
+Measures the gradient variance of MaxRL's policy gradient estimator by sampling
+different rollout subsets from pre-computed data and computing how much the
+resulting policy gradients vary.
+
+This script also supports an ablation on the MaxRL baseline term. Here,
+`BASELINE=True` means we use the standard MaxRL-style mean-centering in the
+numerator:
+
+    (score - mean_score) / (mean_score + epsilon)
+
+and `BASELINE=False` removes only that centering term while keeping the MaxRL
+normalization in the denominator:
+
+    score / (mean_score + epsilon)
+
+So the ablation isolates the effect of the baseline term inside MaxRL rather
+than switching to vanilla REINFORCE.
+
+Within each round, rollout subsets for the same prompt are sampled without
+replacement across subsets, so different subsets do not reuse the same rollout.
+"""
+
+import json
+import os
+import random
+
+import numpy as np
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# ============================================================================
+# Global Configuration
+# ============================================================================
+BATCH_SIZE = 16                 # number of prompts per round
+ROLLOUT_NUM = 4                # rollouts sampled per prompt per subset
+NUMBER_BATCHES_PER_ROUND = 4   # number of different rollout subsets per round
+TOTAL_ROUNDS = 5                # rounds to average over
+BASELINE = False                 # if True: (score - mean)/(mean+eps); if False: score/(mean+eps)
+
+MODEL_PATH = "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/smollm2_0.3B_MaxRL_gsm8k_1000_steps"
+DATA_PATH = "/work/nvme/bgif/gzeng/MAXRL/variance_analysis/data/SmolLM/512x512.jsonl"
+MAX_SEQ_LEN = 2048  # truncate sequences longer than this
+MICRO_BATCH_SIZE = 8  # for forward/backward to avoid OOM
+SEED = 42
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+DTYPE = torch.bfloat16 if torch.cuda.is_available() else torch.float32
+
+
+# ============================================================================
+# Data Loading
+# ============================================================================
+def load_rollout_data(data_path: str) -> dict:
+    """Load pre-computed rollouts and group by prompt.
+
+    Returns:
+        dict mapping prompt_id (int) -> {
+            "input": str,
+            "rollouts": [{"output": str, "score": float}, ...]
+        }
+    """
+    prompt_to_id = {}
+    prompt_data = {}
+
+    with open(data_path, "r") as f:
+        for line in f:
+            item = json.loads(line)
+            prompt_text = item["input"]
+            if prompt_text not in prompt_to_id:
+                pid = len(prompt_to_id)
+                prompt_to_id[prompt_text] = pid
+                prompt_data[pid] = {"input": prompt_text, "rollouts": []}
+            pid = prompt_to_id[prompt_text]
+            prompt_data[pid]["rollouts"].append({
+                "output": item["output"],
+                "score": item["score"],
+            })
+
+    print(f"Loaded {len(prompt_data)} prompts, "
+          f"each with {len(prompt_data[0]['rollouts'])} rollouts")
+    return prompt_data
+
+
+# ============================================================================
+# MaxRL Advantage Computation
+# ============================================================================
+def compute_maxrl_advantage(scores: list[float], epsilon: float = 1e-6) -> list[float]:
+    """Compute MaxRL-style advantages for a single prompt's rollouts.
+
+    This function is used to study the effect of the baseline term in MaxRL.
+
+    If BASELINE is True:
+        advantage_j = (score_j - mean) / (mean + epsilon)
+
+    If BASELINE is False:
+        advantage_j = score_j / (mean + epsilon)
+
+    In both cases, the denominator stays the same. The ablation only removes
+    the baseline/mean-centering term from the numerator.
+    """
+    mean = sum(scores) / len(scores)
+    if BASELINE:
+        return [(s - mean) / (mean + epsilon) for s in scores]
+    else:
+        return [(s - 0.0) / (mean + epsilon) for s in scores]
+
+
+# ============================================================================
+# Log Probability Computation
+# ============================================================================
+def tokenize_and_get_response_mask(
+    tokenizer,
+    prompt: str,
+    response: str,
+    max_seq_len: int,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """Tokenize prompt+response and create a response-only mask.
+
+    Returns:
+        input_ids: (seq_len,) token ids
+        response_mask: (seq_len,) binary mask, 1 for response tokens
+    """
+    prompt_ids = tokenizer.encode(prompt, add_special_tokens=False)
+    response_ids = tokenizer.encode(response, add_special_tokens=False)
+
+    # Truncate if needed
+    total_len = len(prompt_ids) + len(response_ids)
+    if total_len > max_seq_len:
+        # Keep full prompt, truncate response
+        max_resp = max_seq_len - len(prompt_ids)
+        if max_resp <= 0:
+            # Prompt itself is too long, truncate prompt too
+            prompt_ids = prompt_ids[:max_seq_len // 2]
+            max_resp = max_seq_len - len(prompt_ids)
+        response_ids = response_ids[:max_resp]
+
+    input_ids = prompt_ids + response_ids
+    response_mask = [0] * len(prompt_ids) + [1] * len(response_ids)
+
+    return (
+        torch.tensor(input_ids, dtype=torch.long),
+        torch.tensor(response_mask, dtype=torch.float32),
+    )
+
+
+def pad_batch(
+    batch_input_ids: list[torch.Tensor],
+    batch_response_masks: list[torch.Tensor],
+    pad_token_id: int,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    """Pad a batch of variable-length sequences.
+
+    Returns:
+        input_ids: (B, max_len)
+        response_mask: (B, max_len)
+        attention_mask: (B, max_len)
+    """
+    max_len = max(ids.shape[0] for ids in batch_input_ids)
+    B = len(batch_input_ids)
+
+    input_ids = torch.full((B, max_len), pad_token_id, dtype=torch.long)
+    response_mask = torch.zeros(B, max_len)
+    attention_mask = torch.zeros(B, max_len)
+
+    for i, (ids, rmask) in enumerate(zip(batch_input_ids, batch_response_masks)):
+        seq_len = ids.shape[0]
+        # Left-pad: place content at the end
+        input_ids[i, max_len - seq_len:] = ids
+        response_mask[i, max_len - seq_len:] = rmask
+        attention_mask[i, max_len - seq_len:] = 1.0
+
+    return input_ids, response_mask, attention_mask
+
+
+def compute_policy_gradient_loss(
+    model,
+    input_ids: torch.Tensor,
+    attention_mask: torch.Tensor,
+    response_mask: torch.Tensor,
+    advantages: torch.Tensor,
+) -> tuple[torch.Tensor, int]:
+    """Compute the token-mean REINFORCE loss for a micro-batch.
+
+    This matches the repo's default `loss_agg_mode=token-mean`: each response
+    token gets the same per-sequence advantage, and we average over valid
+    response tokens.
+
+    Returns:
+        loss: scalar loss (with grad)
+        valid_token_count: number of valid response tokens in this micro-batch
+    """
+    outputs = model(input_ids=input_ids, attention_mask=attention_mask)
+    logits = outputs.logits  # (B, T, V)
+
+    # Shift: predict next token from current position
+    # logits[:, :-1] predicts token at position [:, 1:]
+    shift_logits = logits[:, :-1, :]
+    shift_labels = input_ids[:, 1:]
+    shift_response_mask = response_mask[:, 1:]
+
+    # Log probabilities of the actual tokens
+    log_probs = torch.log_softmax(shift_logits, dim=-1)
+    token_log_probs = torch.gather(
+        log_probs, dim=-1, index=shift_labels.unsqueeze(-1)
+    ).squeeze(-1)  # (B, T-1)
+
+    # Token-level REINFORCE loss with a per-sequence advantage broadcast to
+    # every response token, then aggregated by masked token mean.
+    token_losses = -advantages.unsqueeze(-1) * token_log_probs * shift_response_mask
+    valid_token_count = int(shift_response_mask.sum().item())
+    loss = token_losses.sum() / max(valid_token_count, 1)
+    return loss, valid_token_count
+
+
+# ============================================================================
+# Gradient Collection Utilities
+# ============================================================================
+def collect_flat_gradient(model) -> torch.Tensor:
+    """Flatten all parameter gradients into a single vector (float32)."""
+    grads = []
+    for p in model.parameters():
+        if p.grad is not None:
+            grads.append(p.grad.detach().float().flatten())
+        else:
+            grads.append(torch.zeros(p.numel(), dtype=torch.float32, device=p.device))
+    return torch.cat(grads)
+
+
+def compute_variance_metrics(
+    grad_sum: torch.Tensor,
+    grad_sq_sum: torch.Tensor,
+    K: int,
+    grad_norms: list[float],
+    grad_samples: list[torch.Tensor],
+) -> dict:
+    """Compute variance metrics from accumulated gradient statistics.
+
+    Args:
+        grad_sum: sum of K gradient vectors
+        grad_sq_sum: sum of K element-wise squared gradient vectors
+        K: number of gradient samples
+        grad_norms: list of gradient norms for each sample
+        grad_samples: list of the K gradient vectors for cosine-to-mean stats
+    """
+    grad_mean = grad_sum / K
+    mean_grad_norm = grad_mean.norm().item()
+
+    # Var(g) = E[g^2] - E[g]^2, then sum over dimensions -> trace of covariance
+    # With Bessel correction: multiply by K/(K-1)
+    elementwise_var = (grad_sq_sum / K - grad_mean ** 2) * (K / (K - 1))
+    trace_variance = elementwise_var.sum().item()
+
+    # Relative variance
+    relative_variance = trace_variance / (mean_grad_norm ** 2 + 1e-10)
+
+    cosine_sims_to_mean = []
+    if mean_grad_norm > 0:
+        for grad in grad_samples:
+            cos_sim = torch.nn.functional.cosine_similarity(
+                grad.unsqueeze(0), grad_mean.unsqueeze(0),
+            ).item()
+            cosine_sims_to_mean.append(cos_sim)
+
+    return {
+        "mean_grad_norm": mean_grad_norm,
+        "trace_variance": trace_variance,
+        "relative_variance": relative_variance,
+        "avg_sample_grad_norm": np.mean(grad_norms),
+        "std_sample_grad_norm": np.std(grad_norms),
+        "avg_cosine_similarity_to_mean": (
+            np.mean(cosine_sims_to_mean) if cosine_sims_to_mean else float("nan")
+        ),
+    }
+
+
+# ============================================================================
+# Main Analysis Loop
+# ============================================================================
+def run_variance_analysis():
+    random.seed(SEED)
+    np.random.seed(SEED)
+    torch.manual_seed(SEED)
+
+    # --- Load model and tokenizer ---
+    print(f"Loading model from {MODEL_PATH} ...")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_PATH, torch_dtype=DTYPE,
+    ).to(DEVICE)
+    model.eval()  # keep eval mode (no dropout), but we still need gradients
+    for p in model.parameters():
+        p.requires_grad_(True)
+
+    total_params = sum(p.numel() for p in model.parameters())
+    print(f"Model loaded: {total_params:,} parameters on {DEVICE}")
+
+    # --- Load data ---
+    print(f"Loading rollout data from {DATA_PATH} ...")
+    prompt_data = load_rollout_data(DATA_PATH)
+    all_prompt_ids = list(prompt_data.keys())
+
+    # --- Main loop ---
+    all_round_metrics = []
+
+    for round_idx in range(TOTAL_ROUNDS):
+        print(f"\n{'='*60}")
+        print(f"Round {round_idx + 1}/{TOTAL_ROUNDS}")
+        print(f"{'='*60}")
+
+        # Sample BATCH_SIZE prompts
+        sampled_prompts = random.sample(all_prompt_ids, BATCH_SIZE)
+
+        # Pre-sample disjoint rollout subsets for each prompt in this round.
+        # This keeps subset-to-subset comparisons within a round free of
+        # repeated rollout samples for the same prompt.
+        rollouts_needed_per_prompt = NUMBER_BATCHES_PER_ROUND * ROLLOUT_NUM
+        round_rollout_subsets = {}
+        for pid in sampled_prompts:
+            rollouts = prompt_data[pid]["rollouts"]
+            if len(rollouts) < rollouts_needed_per_prompt:
+                raise ValueError(
+                    "Not enough rollouts for non-overlapping sampling in one round: "
+                    f"prompt {pid} has {len(rollouts)} rollouts, but "
+                    f"{rollouts_needed_per_prompt} are required "
+                    f"({NUMBER_BATCHES_PER_ROUND} subsets x {ROLLOUT_NUM} rollouts)."
+                )
+
+            sampled_rollouts_for_round = random.sample(
+                rollouts, rollouts_needed_per_prompt,
+            )
+            round_rollout_subsets[pid] = [
+                sampled_rollouts_for_round[
+                    subset_start:subset_start + ROLLOUT_NUM
+                ]
+                for subset_start in range(
+                    0, rollouts_needed_per_prompt, ROLLOUT_NUM,
+                )
+            ]
+
+        # Accumulators for this round
+        grad_sum = torch.zeros(total_params, dtype=torch.float32)
+        grad_sq_sum = torch.zeros(total_params, dtype=torch.float32)
+        grad_samples = []
+        grad_norms = []
+
+        for subset_idx in range(NUMBER_BATCHES_PER_ROUND):
+            print(f"  Subset {subset_idx + 1}/{NUMBER_BATCHES_PER_ROUND} ...", end=" ")
+
+            # --- Sample rollouts and compute advantages ---
+            all_input_ids = []
+            all_response_masks = []
+            all_advantages = []
+
+            for pid in sampled_prompts:
+                prompt_text = prompt_data[pid]["input"]
+
+                # Use the pre-sampled non-overlapping subset for this round.
+                sampled_rollouts = round_rollout_subsets[pid][subset_idx]
+                scores = [r["score"] for r in sampled_rollouts]
+                advantages = compute_maxrl_advantage(scores)
+
+                for rollout, adv in zip(sampled_rollouts, advantages):
+                    ids, rmask = tokenize_and_get_response_mask(
+                        tokenizer, prompt_text, rollout["output"], MAX_SEQ_LEN,
+                    )
+                    all_input_ids.append(ids)
+                    all_response_masks.append(rmask)
+                    all_advantages.append(adv)
+
+            # --- Compute policy gradient via micro-batching ---
+            model.zero_grad()
+            num_samples = len(all_input_ids)
+            total_valid_tokens = int(
+                sum(rmask[1:].sum().item() for rmask in all_response_masks)
+            )
+            total_loss = 0.0
+
+            for mb_start in range(0, num_samples, MICRO_BATCH_SIZE):
+                mb_end = min(mb_start + MICRO_BATCH_SIZE, num_samples)
+
+                mb_ids = all_input_ids[mb_start:mb_end]
+                mb_masks = all_response_masks[mb_start:mb_end]
+                mb_advs = all_advantages[mb_start:mb_end]
+
+                input_ids, response_mask, attention_mask = pad_batch(
+                    mb_ids, mb_masks, tokenizer.pad_token_id,
+                )
+                input_ids = input_ids.to(DEVICE)
+                response_mask = response_mask.to(DEVICE)
+                attention_mask = attention_mask.to(DEVICE)
+                advantages_t = torch.tensor(mb_advs, dtype=DTYPE, device=DEVICE)
+
+                mb_loss, mb_valid_tokens = compute_policy_gradient_loss(
+                    model, input_ids, attention_mask, response_mask, advantages_t,
+                )
+                scaled_loss = mb_loss * (mb_valid_tokens / max(total_valid_tokens, 1))
+                scaled_loss.backward()
+                total_loss += mb_loss.item() * (mb_valid_tokens / max(total_valid_tokens, 1))
+
+            # --- Collect gradient ---
+            flat_grad = collect_flat_gradient(model).cpu()
+            grad_norm = flat_grad.norm().item()
+            grad_samples.append(flat_grad)
+            grad_norms.append(grad_norm)
+
+            # Update accumulators
+            grad_sum += flat_grad
+            grad_sq_sum += flat_grad ** 2
+
+            print(f"loss={total_loss:.6f}, grad_norm={grad_norm:.6f}")
+
+        # --- Compute round metrics ---
+        K = NUMBER_BATCHES_PER_ROUND
+        metrics = compute_variance_metrics(grad_sum, grad_sq_sum, K, grad_norms, grad_samples)
+
+        all_round_metrics.append(metrics)
+
+        print(f"\n  Round {round_idx + 1} Results:")
+        print(f"    Mean gradient norm:     {metrics['mean_grad_norm']:.6e}")
+        print(f"    Trace of covariance:    {metrics['trace_variance']:.6e}")
+        print(f"    Relative variance:      {metrics['relative_variance']:.6e}")
+        print(f"    Avg sample grad norm:   {metrics['avg_sample_grad_norm']:.6e}")
+        print(f"    Std sample grad norm:   {metrics['std_sample_grad_norm']:.6e}")
+        print(
+            "    Avg cosine sim to mean:"
+            f"  {metrics['avg_cosine_similarity_to_mean']:.6f}"
+        )
+
+    # --- Average over all rounds ---
+    print(f"\n{'='*60}")
+    print(f"FINAL RESULTS (averaged over {TOTAL_ROUNDS} rounds)")
+    print(f"{'='*60}")
+    print(f"  BATCH_SIZE={BATCH_SIZE}, ROLLOUT_NUM={ROLLOUT_NUM}, "
+          f"NUMBER_BATCHES_PER_ROUND={NUMBER_BATCHES_PER_ROUND}")
+
+    for key in all_round_metrics[0]:
+        values = [m[key] for m in all_round_metrics]
+        mean_val = np.mean(values)
+        std_val = np.std(values)
+        print(f"  {key}: {mean_val:.6e} +/- {std_val:.6e}")
+
+    # --- Save results ---
+    output_path = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)),
+        f"results_bs{BATCH_SIZE}_nr{ROLLOUT_NUM}_nb{NUMBER_BATCHES_PER_ROUND}_r{TOTAL_ROUNDS}_bl{BASELINE}.json",
+    )
+    results = {
+        "config": {
+            "batch_size": BATCH_SIZE,
+            "rollout_num": ROLLOUT_NUM,
+            "number_batches_per_round": NUMBER_BATCHES_PER_ROUND,
+            "total_rounds": TOTAL_ROUNDS,
+            "model_path": MODEL_PATH,
+            "max_seq_len": MAX_SEQ_LEN,
+            "seed": SEED,
+            "baseline": BASELINE,
+        },
+        "per_round": all_round_metrics,
+        "averaged": {
+            key: {
+                "mean": float(np.mean([m[key] for m in all_round_metrics])),
+                "std": float(np.std([m[key] for m in all_round_metrics])),
+            }
+            for key in all_round_metrics[0]
+        },
+    }
+    with open(output_path, "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"\nResults saved to {output_path}")
+
+
+if __name__ == "__main__":
+    run_variance_analysis()

smollm_variance_analysis_auto.py

@@ -0,0 +1,400 @@
+"""
+Automated SmolLM Variance Analysis for MaxRL Policy Gradient.
+
+Runs all 12 experiments (6 rollout_nums x 2 baseline settings) across multiple
+GPUs with dynamic scheduling. Each GPU worker loads the model once and pulls
+experiments from a shared task pool. Saves only trace_covariance mean/std to
+outputs/ and plots the variance line chart.
+"""
+
+import json
+import os
+import random
+from functools import partial
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import torch.multiprocessing as mp
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+# ============================================================================
+# Configuration
+# ============================================================================
+BATCH_SIZE = 16
+ROLLOUT_NUMS = [4, 8, 16, 32, 64, 128]
+NUMBER_BATCHES_PER_ROUND = 4
+TOTAL_ROUNDS = 32
+MICRO_BATCH_SIZE = 8
+MAX_SEQ_LEN = 2048
+SEED = 42
+
+MODEL_PATH = "/work/nvme/bgif/gzeng/MAXRL/checkpoints/math/smollm2_0.3B_MaxRL_gsm8k_1000_steps"
+DATA_PATH = "/work/nvme/bgif/gzeng/MAXRL/variance_analysis/data/SmolLM/512x512.jsonl"
+
+GPU_IDS = [0, 1, 2, 3]
+DTYPE = torch.bfloat16
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+OUTPUT_DIR = os.path.join(SCRIPT_DIR, "outputs", "SmolLM")
+
+
+# ============================================================================
+# Per-worker global state (initialized once per GPU worker)
+# ============================================================================
+_worker_model = None
+_worker_tokenizer = None
+_worker_prompt_data = None
+_worker_all_prompt_ids = None
+_worker_total_params = None
+_worker_device = None
+
+
+def worker_init(gpu_queue: mp.Queue):
+    """Called once per pool worker. Grabs a GPU and loads model + data."""
+    global _worker_model, _worker_tokenizer, _worker_prompt_data
+    global _worker_all_prompt_ids, _worker_total_params, _worker_device
+
+    gpu_id = gpu_queue.get()
+    _worker_device = f"cuda:{gpu_id}"
+    print(f"[Worker PID={os.getpid()}] Assigned to GPU {gpu_id}")
+
+    _worker_tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
+    if _worker_tokenizer.pad_token is None:
+        _worker_tokenizer.pad_token = _worker_tokenizer.eos_token
+
+    _worker_model = AutoModelForCausalLM.from_pretrained(
+        MODEL_PATH, torch_dtype=DTYPE,
+    ).to(_worker_device)
+    _worker_model.eval()
+    for p in _worker_model.parameters():
+        p.requires_grad_(True)
+
+    _worker_total_params = sum(p.numel() for p in _worker_model.parameters())
+    print(f"[GPU {gpu_id}] Model loaded: {_worker_total_params:,} parameters")
+
+    _worker_prompt_data = load_rollout_data(DATA_PATH)
+    _worker_all_prompt_ids = list(_worker_prompt_data.keys())
+
+
+# ============================================================================
+# Data Loading
+# ============================================================================
+def load_rollout_data(data_path: str) -> dict:
+    prompt_to_id = {}
+    prompt_data = {}
+
+    with open(data_path, "r") as f:
+        for line in f:
+            item = json.loads(line)
+            prompt_text = item["input"]
+            if prompt_text not in prompt_to_id:
+                pid = len(prompt_to_id)
+                prompt_to_id[prompt_text] = pid
+                prompt_data[pid] = {"input": prompt_text, "rollouts": []}
+            pid = prompt_to_id[prompt_text]
+            prompt_data[pid]["rollouts"].append({
+                "output": item["output"],
+                "score": item["score"],
+            })
+
+    print(f"Loaded {len(prompt_data)} prompts, "
+          f"each with {len(prompt_data[0]['rollouts'])} rollouts")
+    return prompt_data
+
+
+# ============================================================================
+# MaxRL Advantage Computation
+# ============================================================================
+def compute_maxrl_advantage(
+    scores: list[float], baseline: bool, epsilon: float = 1e-6,
+) -> list[float]:
+    mean = sum(scores) / len(scores)
+    if baseline:
+        return [(s - mean) / (mean + epsilon) for s in scores]
+    else:
+        return [s / (mean + epsilon) for s in scores]
+
+
+# ============================================================================
+# Tokenization & Batching
+# ============================================================================
+def tokenize_and_get_response_mask(
+    tokenizer, prompt: str, response: str, max_seq_len: int,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    prompt_ids = tokenizer.encode(prompt, add_special_tokens=False)
+    response_ids = tokenizer.encode(response, add_special_tokens=False)
+
+    total_len = len(prompt_ids) + len(response_ids)
+    if total_len > max_seq_len:
+        max_resp = max_seq_len - len(prompt_ids)
+        if max_resp <= 0:
+            prompt_ids = prompt_ids[:max_seq_len // 2]
+            max_resp = max_seq_len - len(prompt_ids)
+        response_ids = response_ids[:max_resp]
+
+    input_ids = prompt_ids + response_ids
+    response_mask = [0] * len(prompt_ids) + [1] * len(response_ids)
+
+    return (
+        torch.tensor(input_ids, dtype=torch.long),
+        torch.tensor(response_mask, dtype=torch.float32),
+    )
+
+
+def pad_batch(
+    batch_input_ids: list[torch.Tensor],
+    batch_response_masks: list[torch.Tensor],
+    pad_token_id: int,
+) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    max_len = max(ids.shape[0] for ids in batch_input_ids)
+    B = len(batch_input_ids)
+
+    input_ids = torch.full((B, max_len), pad_token_id, dtype=torch.long)
+    response_mask = torch.zeros(B, max_len)
+    attention_mask = torch.zeros(B, max_len)
+
+    for i, (ids, rmask) in enumerate(zip(batch_input_ids, batch_response_masks)):
+        seq_len = ids.shape[0]
+        input_ids[i, max_len - seq_len:] = ids
+        response_mask[i, max_len - seq_len:] = rmask
+        attention_mask[i, max_len - seq_len:] = 1.0
+
+    return input_ids, response_mask, attention_mask
+
+
+# ============================================================================
+# Policy Gradient Loss
+# ============================================================================
+def compute_policy_gradient_loss(
+    model, input_ids, attention_mask, response_mask, advantages,
+) -> tuple[torch.Tensor, int]:
+    outputs = model(input_ids=input_ids, attention_mask=attention_mask)
+    logits = outputs.logits
+
+    shift_logits = logits[:, :-1, :]
+    shift_labels = input_ids[:, 1:]
+    shift_response_mask = response_mask[:, 1:]
+
+    log_probs = torch.log_softmax(shift_logits, dim=-1)
+    token_log_probs = torch.gather(
+        log_probs, dim=-1, index=shift_labels.unsqueeze(-1),
+    ).squeeze(-1)
+
+    token_losses = -advantages.unsqueeze(-1) * token_log_probs * shift_response_mask
+    valid_token_count = int(shift_response_mask.sum().item())
+    loss = token_losses.sum() / max(valid_token_count, 1)
+    return loss, valid_token_count
+
+
+# ============================================================================
+# Gradient Utilities
+# ============================================================================
+def collect_flat_gradient(model) -> torch.Tensor:
+    grads = []
+    for p in model.parameters():
+        if p.grad is not None:
+            grads.append(p.grad.detach().float().flatten())
+        else:
+            grads.append(torch.zeros(p.numel(), dtype=torch.float32, device=p.device))
+    return torch.cat(grads)
+
+
+def compute_trace_variance(
+    grad_sum: torch.Tensor, grad_sq_sum: torch.Tensor, K: int,
+) -> float:
+    grad_mean = grad_sum / K
+    elementwise_var = (grad_sq_sum / K - grad_mean ** 2) * (K / (K - 1))
+    return elementwise_var.sum().item()
+
+
+# ============================================================================
+# Single Experiment (runs inside a worker process)
+# ============================================================================
+def run_single_experiment(task: tuple[int, bool]) -> tuple[str, dict]:
+    """Run one experiment using the worker's pre-loaded model and data.
+
+    Args:
+        task: (rollout_num, baseline)
+
+    Returns:
+        (key, {"mean": float, "std": float})
+    """
+    rollout_num, baseline = task
+    key = f"nr{rollout_num}_bl{baseline}"
+
+    model = _worker_model
+    tokenizer = _worker_tokenizer
+    prompt_data = _worker_prompt_data
+    all_prompt_ids = _worker_all_prompt_ids
+    total_params = _worker_total_params
+    device = _worker_device
+
+    print(f"[{device}] Starting {key}")
+
+    random.seed(SEED)
+    np.random.seed(SEED)
+    torch.manual_seed(SEED)
+
+    trace_variances = []
+
+    for round_idx in range(TOTAL_ROUNDS):
+        sampled_prompts = random.sample(all_prompt_ids, BATCH_SIZE)
+
+        rollouts_needed = NUMBER_BATCHES_PER_ROUND * rollout_num
+        round_rollout_subsets = {}
+        for pid in sampled_prompts:
+            rollouts = prompt_data[pid]["rollouts"]
+            if len(rollouts) < rollouts_needed:
+                raise ValueError(
+                    f"Prompt {pid} has {len(rollouts)} rollouts, need {rollouts_needed}"
+                )
+            sampled = random.sample(rollouts, rollouts_needed)
+            round_rollout_subsets[pid] = [
+                sampled[s:s + rollout_num]
+                for s in range(0, rollouts_needed, rollout_num)
+            ]
+
+        grad_sum = torch.zeros(total_params, dtype=torch.float32)
+        grad_sq_sum = torch.zeros(total_params, dtype=torch.float32)
+
+        for subset_idx in range(NUMBER_BATCHES_PER_ROUND):
+            all_input_ids = []
+            all_response_masks = []
+            all_advantages = []
+
+            for pid in sampled_prompts:
+                prompt_text = prompt_data[pid]["input"]
+                sampled_rollouts = round_rollout_subsets[pid][subset_idx]
+                scores = [r["score"] for r in sampled_rollouts]
+                advantages = compute_maxrl_advantage(scores, baseline)
+
+                for rollout, adv in zip(sampled_rollouts, advantages):
+                    ids, rmask = tokenize_and_get_response_mask(
+                        tokenizer, prompt_text, rollout["output"], MAX_SEQ_LEN,
+                    )
+                    all_input_ids.append(ids)
+                    all_response_masks.append(rmask)
+                    all_advantages.append(adv)
+
+            model.zero_grad()
+            total_valid_tokens = int(
+                sum(rmask[1:].sum().item() for rmask in all_response_masks)
+            )
+            num_samples = len(all_input_ids)
+
+            for mb_start in range(0, num_samples, MICRO_BATCH_SIZE):
+                mb_end = min(mb_start + MICRO_BATCH_SIZE, num_samples)
+
+                mb_ids = all_input_ids[mb_start:mb_end]
+                mb_masks = all_response_masks[mb_start:mb_end]
+                mb_advs = all_advantages[mb_start:mb_end]
+
+                input_ids, response_mask, attention_mask = pad_batch(
+                    mb_ids, mb_masks, tokenizer.pad_token_id,
+                )
+                input_ids = input_ids.to(device)
+                response_mask = response_mask.to(device)
+                attention_mask = attention_mask.to(device)
+                advantages_t = torch.tensor(mb_advs, dtype=DTYPE, device=device)
+
+                mb_loss, mb_valid_tokens = compute_policy_gradient_loss(
+                    model, input_ids, attention_mask, response_mask, advantages_t,
+                )
+                scaled_loss = mb_loss * (mb_valid_tokens / max(total_valid_tokens, 1))
+                scaled_loss.backward()
+
+            flat_grad = collect_flat_gradient(model).cpu()
+            grad_sum += flat_grad
+            grad_sq_sum += flat_grad ** 2
+
+        trace_var = compute_trace_variance(
+            grad_sum, grad_sq_sum, NUMBER_BATCHES_PER_ROUND,
+        )
+        trace_variances.append(trace_var)
+        print(f"  [{device}] {key} round {round_idx+1}/{TOTAL_ROUNDS}: "
+              f"trace_cov={trace_var:.6e}")
+
+    result = {
+        "mean": float(np.mean(trace_variances)),
+        "std": float(np.std(trace_variances)),
+    }
+    print(f"[{device}] Finished {key}: mean={result['mean']:.6e}, std={result['std']:.6e}")
+    return key, result
+
+
+# ============================================================================
+# Plotting
+# ============================================================================
+def plot_results(results: dict, output_dir: str):
+    rollout_nums = ROLLOUT_NUMS
+
+    means_bl_true = [results[f"nr{nr}_blTrue"]["mean"] for nr in rollout_nums]
+    means_bl_false = [results[f"nr{nr}_blFalse"]["mean"] for nr in rollout_nums]
+
+    fig, ax = plt.subplots(figsize=(7, 5))
+
+    ax.plot(rollout_nums, means_bl_true, marker='o', label='MaxRL')
+    ax.plot(rollout_nums, means_bl_false, marker='s', label='MaxRL (w/o baseline)')
+
+    ax.set_xscale('log', base=2)
+    ax.set_xticks(rollout_nums)
+    ax.set_xticklabels(rollout_nums)
+    ax.set_xlabel('Rollout', fontsize=14)
+    ax.set_ylabel('Gradient Variance', fontsize=14)
+    ax.legend(fontsize=12)
+    ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    plt.savefig(os.path.join(output_dir, "variance_plot.pdf"), dpi=300)
+    plt.savefig(os.path.join(output_dir, "variance_plot.png"), dpi=300)
+    print(f"Plots saved to {output_dir}/variance_plot.{{pdf,png}}")
+
+
+# ============================================================================
+# Main
+# ============================================================================
+def main():
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    # Build task list: 12 experiments
+    tasks = []
+    for rollout_num in ROLLOUT_NUMS:
+        for baseline in [True, False]:
+            tasks.append((rollout_num, baseline))
+
+    print(f"Scheduling {len(tasks)} experiments across {len(GPU_IDS)} GPUs")
+
+    # GPU queue: each worker grabs one GPU ID on init
+    gpu_queue = mp.Queue()
+    for gid in GPU_IDS:
+        gpu_queue.put(gid)
+
+    # Pool of workers = number of GPUs. Each worker inits once (loads model),
+    # then processes tasks dynamically from the pool.
+    with mp.Pool(
+        processes=len(GPU_IDS),
+        initializer=worker_init,
+        initargs=(gpu_queue,),
+    ) as pool:
+        results_list = pool.map(run_single_experiment, tasks)
+
+    # Collect results
+    results = dict(results_list)
+
+    # Save
+    results_path = os.path.join(OUTPUT_DIR, "results.json")
+    with open(results_path, "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"Results saved to {results_path}")
+
+    # Plot
+    plot_results(results, OUTPUT_DIR)
+    print("All done!")
+
+
+if __name__ == "__main__":
+    mp.set_start_method("spawn")
+    main()