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