smollm_variance_analysis.py

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