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