smollm_snr_analysis_auto.py

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