scripts/inference_benchmark.py

"""
Inference throughput benchmark for Dense vs RemixedLinear models.

Measures tokens/sec, peak memory, and actual hardware FLOPs.
Optionally evaluates CORE benchmark before/after INT8 template quantization.
Designed to be run on a single GPU for fair comparison.

Usage:
    # Dense d12 baseline
    python scripts/inference_benchmark.py \
        --checkpoint-dir /path/to/ckpt_base/base --batch-size 8

    # RemixedLinear d12
    python scripts/inference_benchmark.py \
        --checkpoint-dir /path/to/ckpt_remixed-linear/remixed-linear --batch-size 8

    # RemixedLinear with INT8 comparison + CORE eval
    python scripts/inference_benchmark.py \
        --checkpoint-dir /path/to/ckpt_remixed-linear/remixed-linear \
        --batch-size 64 --eval-core --add-int8
"""
from __future__ import annotations

import argparse
import json
import os
import sys
import time

# Ensure repo root is on path when run from Modal volumes or other non-installed environments.
_SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
for _candidate in [
    os.path.dirname(_SCRIPT_DIR),   # scripts/../  (standard layout)
    "/root/nanochat",               # Modal default mount point
    _SCRIPT_DIR,                    # fallback: script itself at repo root
]:
    if os.path.isdir(os.path.join(_candidate, "nanochat")):
        if _candidate not in sys.path:
            sys.path.insert(0, _candidate)
        break

import torch
import torch.nn.functional as F

from nanochat.checkpoint_manager import build_model, find_last_step
from nanochat.common import autodetect_device_type


@torch.no_grad()
def count_hardware_flops(model, device, batch_size: int = 8,
                         seq_len: int = 2048) -> dict:
    """Count actual hardware FLOPs using torch.utils.flop_counter."""
    model.eval()
    vocab_size = model.config.vocab_size
    input_ids = torch.randint(0, vocab_size, (batch_size, seq_len), device=device)

    from torch.utils.flop_counter import FlopCounterMode

    # Run once to warm up
    _ = model(input_ids)
    if device.type == 'cuda':
        torch.cuda.synchronize()

    # Count FLOPs
    flop_counter = FlopCounterMode(display=False)
    with flop_counter:
        _ = model(input_ids)

    total_flops = flop_counter.get_total_flops()
    tokens = batch_size * seq_len
    flops_per_token = total_flops / tokens

    # Get per-module breakdown (top-level only)
    flops_by_module = {}
    try:
        for name, mod_flops in flop_counter.get_flop_counts().items():
            total_mod = sum(mod_flops.values())
            if total_mod > 0:
                flops_by_module[str(name)] = total_mod
    except Exception:
        pass  # older PyTorch versions may not support this

    return {
        'hw_total_flops': total_flops,
        'hw_flops_per_token': flops_per_token,
        'hw_flops_by_module': flops_by_module,
    }


@torch.no_grad()
def benchmark_throughput(model, device, batch_size: int = 8,
                         seq_len: int = 2048, warmup_steps: int = 5,
                         measure_steps: int = 20) -> dict:
    """Measure inference throughput in tokens/sec."""
    model.eval()
    vocab_size = model.config.vocab_size

    # Generate random input tokens
    input_ids = torch.randint(0, vocab_size, (batch_size, seq_len), device=device)

    # Warmup
    print(f"  Warming up ({warmup_steps} steps)...")
    for _ in range(warmup_steps):
        _ = model(input_ids)
        if device.type == 'cuda':
            torch.cuda.synchronize()

    # Reset memory stats after warmup
    if device.type == 'cuda':
        torch.cuda.reset_peak_memory_stats()

    # Measure
    print(f"  Measuring ({measure_steps} steps)...")
    times = []
    for _ in range(measure_steps):
        if device.type == 'cuda':
            torch.cuda.synchronize()
        t0 = time.perf_counter()
        _ = model(input_ids)
        if device.type == 'cuda':
            torch.cuda.synchronize()
        t1 = time.perf_counter()
        times.append(t1 - t0)

    tokens_per_step = batch_size * seq_len
    avg_time = sum(times) / len(times)
    std_time = (sum((t - avg_time) ** 2 for t in times) / len(times)) ** 0.5

    peak_mem_gb = 0.0
    if device.type == 'cuda':
        peak_mem_gb = torch.cuda.max_memory_allocated() / (1024 ** 3)

    results = {
        'tokens_per_sec': tokens_per_step / avg_time,
        'avg_latency_ms': avg_time * 1000,
        'std_latency_ms': std_time * 1000,
        'batch_size': batch_size,
        'seq_len': seq_len,
        'tokens_per_step': tokens_per_step,
        'peak_memory_gb': round(peak_mem_gb, 2),
        'measure_steps': measure_steps,
    }
    return results


def run_core_eval(model, tokenizer, device, max_per_task=500):
    """Run CORE evaluation using an already-loaded tokenizer."""
    from scripts.base_eval import evaluate_core

    print(f"\n  Running CORE evaluation (max {max_per_task} examples per task)...")
    results = evaluate_core(model, tokenizer, device, max_per_task=max_per_task)
    core_score = results['core_metric']

    # Print per-task breakdown
    print(f"\n  {'Task':<35} {'Accuracy':>10} {'Centered':>10}")
    print(f"  {'-'*35} {'-'*10} {'-'*10}")
    for label in results['results']:
        acc = results['results'][label]
        centered = results['centered_results'][label]
        print(f"  {label:<35} {acc:>10.4f} {centered:>10.4f}")
    print(f"  {'CORE (aggregate)':<35} {'':>10} {core_score:>10.4f}")

    return results


def print_results(results, label="Results"):
    """Print formatted benchmark results."""
    model_tag = results.get('model_tag', 'unknown')
    print(f"\n{'='*60}")
    print(f"{label} ({model_tag})")
    print(f"{'='*60}")
    print(f"  Throughput:      {results['tokens_per_sec']:,.0f} tokens/sec")
    print(f"  Avg latency:     {results['avg_latency_ms']:.1f} ms ± {results['std_latency_ms']:.1f} ms")
    print(f"  Peak memory:     {results['peak_memory_gb']:.2f} GB")
    print(f"  Tokens/step:     {results['tokens_per_step']:,}")
    if 'hw_flops_per_token' in results:
        print(f"  HW FLOPs/token:  {results['hw_flops_per_token']:.2e}")
        throughput = results['tokens_per_sec']
        hw_tflops = results['hw_flops_per_token'] * throughput / 1e12
        print(f"  HW TFLOPS:       {hw_tflops:.1f}")
    if 'core_score' in results:
        print(f"  CORE score:      {results['core_score']:.4f}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Inference throughput benchmark")
    parser.add_argument("--checkpoint-dir", type=str, required=True,
                        help="Path to checkpoint directory containing model_XXXXXX.pt and meta_XXXXXX.json")
    parser.add_argument("--step", type=int, default=None,
                        help="Checkpoint step to load (default: latest)")
    parser.add_argument("--batch-size", type=int, default=8, help="Batch size for benchmark")
    parser.add_argument("--seq-len", type=int, default=None,
                        help="Sequence length (default: from model config)")
    parser.add_argument("--warmup-steps", type=int, default=5, help="Warmup iterations")
    parser.add_argument("--measure-steps", type=int, default=20, help="Measurement iterations")
    parser.add_argument("--compile", action="store_true", help="Use torch.compile")
    parser.add_argument("--no-flop-count", action="store_true", help="Skip hardware FLOP counting")
    parser.add_argument("--tokenizer-dir", type=str, default=None)
    parser.add_argument("--output", type=str, default=None, help="Output JSON path (default: auto)")
    # New flags
    parser.add_argument("--eval-core", action="store_true",
                        help="Run CORE benchmark evaluation (22 tasks, max 500 examples each)")
    parser.add_argument("--core-max-per-task", type=int, default=500,
                        help="Max examples per CORE task (default: 500)")
    parser.add_argument("--add-int8", action="store_true",
                        help="After normal benchmark, apply INT8 template quantization and re-benchmark. "
                             "Only affects RemixedLinear models (dense models have no template banks).")
    args = parser.parse_args()

    device_type = autodetect_device_type()
    device = torch.device(device_type)

    # Find latest step if not specified
    step = args.step
    if step is None:
        step = find_last_step(args.checkpoint_dir)
    print(f"Loading step {step} from {args.checkpoint_dir}")

    # Build model from checkpoint (reads model_config from meta JSON)
    model, tokenizer, meta_data = build_model(
        args.checkpoint_dir, step, device, phase="eval",
        tokenizer_dir=args.tokenizer_dir,
    )

    # Override seq_len if requested
    seq_len = args.seq_len or model.config.sequence_len

    # Model info
    config = model.config
    total_params = sum(p.numel() for p in model.parameters())
    try:
        est_total_flops, est_active_flops, active_params = model.estimate_flops()
    except Exception:
        est_total_flops = est_active_flops = active_params = 0
    is_remix = config.use_remix_linear
    model_tag = "remix" if is_remix else "dense"

    print(f"\n{'='*60}")
    print(f"Inference Throughput Benchmark")
    print(f"{'='*60}")
    print(f"  Device:        {device_type}")
    if device_type == 'cuda':
        print(f"  GPU:           {torch.cuda.get_device_name(0)}")
    print(f"  Checkpoint:    {args.checkpoint_dir}")
    print(f"  Step:          {step}")
    print(f"  Model:         {model_tag}")
    print(f"  n_layer:       {config.n_layer}")
    print(f"  n_embd:        {config.n_embd}")
    print(f"  Total params:  {total_params:,}")
    print(f"  Active params: {active_params:,}")
    print(f"  Est. Total FLOPs/tok: {est_total_flops:.2e}")
    print(f"  Est. Active FLOPs/tok: {est_active_flops:.2e}")
    print(f"  Batch:         {args.batch_size}")
    print(f"  Seq len:       {seq_len}")
    print(f"  Compile:       {args.compile}")
    if is_remix:
        rl_kw = config.remixed_linear_kwargs or {}
        print(f"  K templates:   {rl_kw.get('n_templates', '?')}")
        print(f"  Chunk size:    {rl_kw.get('chunk_routing_size', '?')}")
    print()

    # ── Phase 1: Hardware FLOP counting (before compile) ──────────────────
    hw_flops_results = {}
    if not args.no_flop_count:
        print("Counting actual hardware FLOPs...")
        try:
            hw_flops_results = count_hardware_flops(model, device,
                                                     batch_size=args.batch_size,
                                                     seq_len=seq_len)
            hw_fpt = hw_flops_results['hw_flops_per_token']
            print(f"  Hardware FLOPs/token: {hw_fpt:.2e}")
            print(f"  Hardware total FLOPs:  {hw_flops_results['hw_total_flops']:.2e}")
            if est_active_flops > 0:
                print(f"  HW/Est. Active ratio:  {hw_fpt / est_active_flops:.2f}x")
            print()
        except Exception as e:
            print(f"  FLOP counting failed: {e}")
            print(f"  (requires PyTorch >= 2.1 with torch.utils.flop_counter)")
            print()

    if args.compile:
        print("Compiling model with torch.compile...")
        model = torch.compile(model)

    # ── Phase 2: CORE eval ────────────────────────────────────────────────
    core_results_bf16 = None
    if args.eval_core:
        quant_label = "INT8 templates" if args.add_int8 else "bf16"
        print(f"\n{'='*60}")
        print(f"CORE Evaluation ({quant_label})")
        print(f"{'='*60}")
        # Apply INT8 *before* CORE if --add-int8, so CORE reflects quantized model
        if args.add_int8:
            if not is_remix:
                print("\n\u26a0  --add-int8 has no effect on dense models.")
            else:
                print("Applying INT8 template quantization before CORE eval...")
                from nanochat.kernels.int8_templates import quantize_remix_model
                _quant_stats_pre = quantize_remix_model(model, verbose=True)
        core_results_bf16 = run_core_eval(
            model, tokenizer, device,
            max_per_task=args.core_max_per_task,
        )

    # ── Phase 3: Throughput benchmark ─────────────────────────────────────
    quant_label = "INT8 templates" if (args.add_int8 and is_remix) else "bf16"
    print(f"\n{'='*60}")
    print(f"Throughput Benchmark ({quant_label})")
    print(f"{'='*60}")
    # If INT8 wasn't applied before CORE (or CORE was skipped), apply now
    if args.add_int8 and is_remix and not args.eval_core:
        print("Applying INT8 template quantization...")
        from nanochat.kernels.int8_templates import quantize_remix_model
        quantize_remix_model(model, verbose=True)
    results_bf16 = benchmark_throughput(
        model, device,
        batch_size=args.batch_size,
        seq_len=seq_len,
        warmup_steps=args.warmup_steps,
        measure_steps=args.measure_steps,
    )

    # Add model info to results
    results_bf16['model_tag'] = model_tag
    results_bf16['n_layer'] = config.n_layer
    results_bf16['n_embd'] = config.n_embd
    results_bf16['total_params'] = total_params
    results_bf16['active_params'] = active_params
    results_bf16['est_total_flops_per_token'] = est_total_flops
    results_bf16['est_active_flops_per_token'] = est_active_flops
    results_bf16.update(hw_flops_results)
    results_bf16['device'] = device_type
    results_bf16['step'] = step
    results_bf16['quantization'] = 'int8_templates' if (args.add_int8 and is_remix) else 'bf16'
    if device_type == 'cuda':
        results_bf16['gpu_name'] = torch.cuda.get_device_name(0)
    results_bf16['compiled'] = args.compile
    if is_remix:
        rl_kw = config.remixed_linear_kwargs or {}
        results_bf16['n_templates'] = rl_kw.get('n_templates', None)
        results_bf16['chunk_routing_size'] = rl_kw.get('chunk_routing_size', None)
    if core_results_bf16:
        results_bf16['core_score'] = core_results_bf16['core_metric']

    print_results(results_bf16, label="Results (bf16)")



    # ── Save results ────────────────────────────────────────────────
    out_path = args.output or f"inference_bench_{model_tag}_d{config.n_layer}.json"
    save_data = {k: v for k, v in results_bf16.items() if k != 'hw_flops_by_module'}
    with open(out_path, 'w') as f:
        json.dump(save_data, f, indent=2)
    print(f"Results saved to {out_path}")


if __name__ == "__main__":
    main()