maze_variance_analysis_auto.py

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