Upload folder using huggingface_hub

make_hellaswag_subset.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""Extract a seeded-random 400-task subset of HellaSwag matching GPTQModel's selection."""
+
+import random
+import sys
+from pathlib import Path
+
+SEED = 1
+N_SAMPLES = 400
+LINES_PER_TASK = 6
+
+def main():
+    root = Path(__file__).resolve().parent.parent
+    full_path = root / "hellaswag_val_full.txt"
+    out_path = root / "hellaswag_val_400.txt"
+
+    lines = full_path.read_text().splitlines()
+    n_tasks = len(lines) // LINES_PER_TASK
+
+    indices = list(range(n_tasks))
+    rng = random.Random(SEED)
+    rng.shuffle(indices)
+    selected = indices[:N_SAMPLES]
+
+    with open(out_path, "w") as f:
+        for idx in selected:
+            start = idx * LINES_PER_TASK
+            for line in lines[start:start + LINES_PER_TASK]:
+                f.write(line + "\n")
+
+    print(f"Wrote {N_SAMPLES} tasks to {out_path}")
+
+if __name__ == "__main__":
+    main()

measure_ttft.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Measure TTFT and TPOT by streaming from llama-server."""
+
+import argparse
+import json
+import subprocess
+import sys
+import time
+import requests
+
+SERVER_BIN = "./build/bin/llama-server"
+PORT = 8081
+PROMPT = "Explain the difference between machine learning and deep learning in detail." * 8  # ~512 tokens
+MAX_TOKENS = 128
+RUNS = 3
+
+
+def wait_for_server(address, timeout=120):
+    for _ in range(timeout):
+        try:
+            r = requests.get(f"{address}/health", timeout=2)
+            if r.status_code == 200:
+                return True
+        except Exception:
+            pass
+        time.sleep(1)
+    return False
+
+
+def measure_once(address):
+    payload = {
+        "messages": [{"role": "user", "content": PROMPT}],
+        "max_tokens": MAX_TOKENS,
+        "stream": True,
+        "temperature": 0.0,
+    }
+    t0 = time.perf_counter()
+    ttft = None
+    n_tokens = 0
+    with requests.post(f"{address}/v1/chat/completions", json=payload, stream=True, timeout=120) as resp:
+        for line in resp.iter_lines():
+            if not line:
+                continue
+            line = line.decode("utf-8")
+            if not line.startswith("data:"):
+                continue
+            data = line[5:].strip()
+            if data == "[DONE]":
+                break
+            try:
+                chunk = json.loads(data)
+                delta = chunk["choices"][0]["delta"].get("content", "")
+                if delta:
+                    if ttft is None:
+                        ttft = time.perf_counter() - t0
+                    n_tokens += 1
+            except Exception:
+                continue
+    t_total = time.perf_counter() - t0
+    tpot = (t_total - ttft) / max(n_tokens - 1, 1) if n_tokens > 1 else 0
+    return ttft, tpot, n_tokens, t_total
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-m", "--model", required=True)
+    parser.add_argument("--runs", type=int, default=RUNS)
+    parser.add_argument("--device", default=None,
+                        help="GGML device string, e.g. CUDA0 (default: all GPUs)")
+    args = parser.parse_args()
+
+    address = f"http://127.0.0.1:{PORT}"
+    cmd = [SERVER_BIN, "-m", args.model, "-ngl", "99", "--port", str(PORT), "--log-disable"]
+    if args.device:
+        cmd += ["-dev", args.device]
+    print(f"Starting server: {' '.join(cmd)}", file=sys.stderr)
+    proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+    try:
+        if not wait_for_server(address):
+            print("ERROR: server did not start", file=sys.stderr)
+            proc.kill()
+            sys.exit(1)
+        print("Server ready", file=sys.stderr)
+
+        ttfts, tpots = [], []
+        for i in range(args.runs):
+            ttft, tpot, n_tokens, t_total = measure_once(address)
+            ttfts.append(ttft * 1000)
+            tpots.append(tpot * 1000)
+            print(f"  Run {i+1}: TTFT={ttft*1000:.1f}ms  TPOT={tpot*1000:.1f}ms  tokens={n_tokens}", file=sys.stderr)
+
+        avg_ttft = sum(ttfts) / len(ttfts)
+        avg_tpot = sum(tpots) / len(tpots)
+        result = {"ttft_ms": round(avg_ttft, 1), "tpot_ms": round(avg_tpot, 1), "latency_ms": round(avg_ttft + avg_tpot, 1)}
+        print(json.dumps(result))
+    finally:
+        proc.kill()
+        proc.wait()
+
+
+if __name__ == "__main__":
+    main()

parse_results.py

@@ -0,0 +1,407 @@
+#!/usr/bin/env python3
+"""Parse all benchmark result files and print both summary tables + write CSV."""
+
+import json
+import os
+import re
+import csv
+
+RESULTS_DIR = os.path.dirname(os.path.abspath(__file__))
+
+KEYS = [
+    ("llama-3.1-8b-instruct", "Llama-3.1-8B", "f16",    "F16"),
+    ("llama-3.1-8b-instruct", "Llama-3.1-8B", "Q8_0",   "Q8_0"),
+    ("llama-3.1-8b-instruct", "Llama-3.1-8B", "Q4_K_M", "Q4_K_M"),
+    ("llama-3.1-8b-instruct", "Llama-3.1-8B", "Q2_K",   "Q2_K"),
+    ("qwen2.5-7b-instruct",   "Qwen2.5-7B",   "f16",    "F16"),
+    ("qwen2.5-7b-instruct",   "Qwen2.5-7B",   "Q8_0",   "Q8_0"),
+    ("qwen2.5-7b-instruct",   "Qwen2.5-7B",   "Q4_K_M", "Q4_K_M"),
+    ("qwen2.5-7b-instruct",   "Qwen2.5-7B",   "Q2_K",   "Q2_K"),
+    ("gemma-2-9b-it",         "Gemma-2-9B",   "f16",    "F16"),
+    ("gemma-2-9b-it",         "Gemma-2-9B",   "Q8_0",   "Q8_0"),
+    ("gemma-2-9b-it",         "Gemma-2-9B",   "Q4_K_M", "Q4_K_M"),
+    ("gemma-2-9b-it",         "Gemma-2-9B",   "Q2_K",   "Q2_K"),
+]
+
+
+def path(prefix, suffix):
+    return os.path.join(RESULTS_DIR, f"{prefix}_{suffix}")
+
+
+def parse_bench(prefix):
+    """Return (prefill_ts, prefill_std, decode_ts, decode_std, weight_gib) or Nones."""
+    p = path(prefix, "bench.json")
+    if not os.path.exists(p):
+        return None, None, None, None, None
+    try:
+        data = json.load(open(p))
+        prefill_ts = prefill_std = decode_ts = decode_std = weight_gib = None
+        for r in data:
+            if r.get("n_prompt", 0) > 0 and r.get("n_gen", 0) == 0:
+                prefill_ts = round(r["avg_ts"], 1)
+                prefill_std = round(r.get("stddev_ts", 0), 1)
+                weight_gib = round(r["model_size"] / (1024**3), 2)
+            elif r.get("n_gen", 0) > 0 and r.get("n_prompt", 0) == 0:
+                decode_ts = round(r["avg_ts"], 1)
+                decode_std = round(r.get("stddev_ts", 0), 1)
+        return prefill_ts, prefill_std, decode_ts, decode_std, weight_gib
+    except Exception as e:
+        print(f"  WARN bench parse error for {prefix}: {e}")
+        return None, None, None, None, None
+
+
+def parse_vram(prefix):
+    """Return peak VRAM (GiB) from nvidia-smi dmon log.
+
+    When monitoring a single GPU (-i N), this is simply the max fb value seen.
+    When monitoring all GPUs (older logs), we fall back to sum of
+    (peak − min) per GPU as an estimate of our job's incremental VRAM.
+    """
+    p = path(prefix, "vram.log")
+    if not os.path.exists(p):
+        return None
+    try:
+        from collections import defaultdict
+        gpu_min = defaultdict(lambda: float("inf"))
+        gpu_max = defaultdict(lambda: 0)
+        with open(p) as f:
+            has_timestamp = False
+            for header_line in f:
+                if header_line.strip().startswith("#") and "Time" in header_line:
+                    has_timestamp = True
+                if not header_line.strip().startswith("#"):
+                    break
+            f.seek(0)
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith("#"):
+                    continue
+                parts = line.split()
+                if len(parts) < 3:
+                    continue
+                try:
+                    if has_timestamp:
+                        # cols: HH:MM:SS  gpu_idx  fb_mb  bar1_mb  ...
+                        gpu = int(parts[1])
+                        fb  = int(parts[2])
+                    else:
+                        # cols: gpu_idx  fb_mb  bar1_mb  ccpm_mb
+                        gpu = int(parts[0])
+                        fb  = int(parts[1])
+                    if fb < gpu_min[gpu]:
+                        gpu_min[gpu] = fb
+                    if fb > gpu_max[gpu]:
+                        gpu_max[gpu] = fb
+                except (ValueError, IndexError):
+                    continue
+        if not gpu_max:
+            return None
+        n_gpus = len(gpu_max)
+        if n_gpus == 1:
+            # Single-GPU log: peak fb is exactly our job's peak VRAM
+            peak_mib = max(gpu_max.values())
+        else:
+            # Multi-GPU log: use delta (peak - min) per GPU to strip baseline
+            peak_mib = sum(gpu_max[g] - gpu_min[g] for g in gpu_max)
+        return round(peak_mib / 1024, 2)
+    except Exception as e:
+        print(f"  WARN vram parse error for {prefix}: {e}")
+        return None
+
+
+def parse_ttft(prefix):
+    """Return (ttft_ms, tpot_ms, latency_ms) or (None, None, None)."""
+    p = path(prefix, "ttft.json")
+    if not os.path.exists(p):
+        return None, None, None
+    try:
+        d = json.load(open(p))
+        return d.get("ttft_ms"), d.get("tpot_ms"), d.get("latency_ms")
+    except Exception as e:
+        print(f"  WARN ttft parse error for {prefix}: {e}")
+        return None, None, None
+
+
+def parse_ppl(prefix):
+    """Return (perplexity, ppl_std) or (None, None)."""
+    p = path(prefix, "ppl.txt")
+    if not os.path.exists(p):
+        return None, None
+    try:
+        text = open(p).read()
+        m = re.search(r"PPL\s*=\s*([\d.]+)\s*\+/-\s*([\d.]+)", text)
+        if m:
+            return float(m.group(1)), float(m.group(2))
+        m = re.search(r"PPL\s*=\s*([\d.]+)", text)
+        return (float(m.group(1)), None) if m else (None, None)
+    except Exception as e:
+        print(f"  WARN ppl parse error for {prefix}: {e}")
+        return None, None
+
+
+def parse_hellaswag(prefix):
+    """Return accuracy % float or None."""
+    p = path(prefix, "hellaswag.txt")
+    if not os.path.exists(p):
+        return None
+    try:
+        text = open(p).read().strip()
+        # format: "400\t78.50000000%\t[74.2%, 82.2%]"
+        m = re.search(r"([\d.]+)%", text)
+        return round(float(m.group(1)), 2) if m else None
+    except Exception as e:
+        print(f"  WARN hellaswag parse error for {prefix}: {e}")
+        return None
+
+
+def parse_winogrande(prefix):
+    """Return accuracy % float or None."""
+    p = path(prefix, "winogrande.txt")
+    if not os.path.exists(p):
+        return None
+    try:
+        text = open(p).read().strip()
+        # format: "1267\t73.4807\t..."  — second col is % correct
+        parts = text.split()
+        return round(float(parts[1]), 2) if len(parts) >= 2 else None
+    except Exception as e:
+        print(f"  WARN winogrande parse error for {prefix}: {e}")
+        return None
+
+
+def fmt(val, fmt_str, missing="—"):
+    return format(val, fmt_str) if val is not None else missing
+
+
+def main():
+    rows = []
+    for (file_prefix_base, model_label, quant_file, quant_label) in KEYS:
+        prefix = f"{file_prefix_base}-{quant_file}"
+        prefill, prefill_std, decode, decode_std, weight = parse_bench(prefix)
+        peak_vram                = parse_vram(prefix)
+        ttft, tpot, latency      = parse_ttft(prefix)
+        ppl, ppl_std             = parse_ppl(prefix)
+        hellaswag                = parse_hellaswag(prefix)
+        winogrande               = parse_winogrande(prefix)
+
+        rows.append({
+            "model":        model_label,
+            "quant":        quant_label,
+            "prefill_ts":   prefill,
+            "prefill_std":  prefill_std,
+            "decode_ts":    decode,
+            "decode_std":   decode_std,
+            "weight_gib":   weight,
+            "peak_vram":    peak_vram,
+            "ttft_ms":      ttft,
+            "tpot_ms":      tpot,
+            "latency_ms":   latency,
+            "ppl":          ppl,
+            "ppl_std":      ppl_std,
+            "hellaswag":    hellaswag,
+            "winogrande":   winogrande,
+        })
+
+    # ── Write CSV ─────────────────────────────────────────────────────────────
+    csv_path = os.path.join(RESULTS_DIR, "benchmark_results.csv")
+    fieldnames = ["model", "quant", "prefill_ts", "prefill_std",
+                  "decode_ts", "decode_std",
+                  "ttft_ms", "tpot_ms", "latency_ms",
+                  "weight_gib", "peak_vram",
+                  "ppl", "ppl_std", "hellaswag", "winogrande"]
+    with open(csv_path, "w", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=fieldnames)
+        w.writeheader()
+        w.writerows(rows)
+    print(f"CSV written → {csv_path}\n")
+
+    # ── Table 1: Speed & Memory ───────────────────────────────────────────────
+    print("TABLE 1 — Speed & Memory")
+    print("─" * 120)
+    hdr = (f"{'Model':<22} {'Quant':<8} {'Prefill (t/s)':>18} {'Decode (t/s)':>18}"
+           f" {'TTFT':>8} {'TPOT':>8} {'Latency':>9} {'Wt(GiB)':>8} {'PkVRAM':>8}")
+    print(hdr)
+    print(f"{'':22} {'':8} {'mean ± std':>18} {'mean ± std':>18}"
+          f" {'(ms)':>8} {'(ms)':>8} {'(ms)':>9} {'':>8} {'(GiB)':>8}")
+    print("─" * 120)
+
+    prev_model = None
+    for r in rows:
+        if r["model"] != prev_model and prev_model is not None:
+            print()
+        prev_model = r["model"]
+        idx = rows.index(r)
+        is_first = idx == 0 or rows[idx-1]["model"] != r["model"]
+
+        if r["prefill_ts"] is not None and r["prefill_std"] is not None:
+            prefill_col = f"{r['prefill_ts']:.1f}±{r['prefill_std']:.1f}"
+        else:
+            prefill_col = "—"
+        if r["decode_ts"] is not None and r["decode_std"] is not None:
+            decode_col = f"{r['decode_ts']:.1f}±{r['decode_std']:.1f}"
+        else:
+            decode_col = "—"
+
+        print(
+            f"{r['model'] if is_first else '':22}"
+            f" {r['quant']:<8}"
+            f" {prefill_col:>18}"
+            f" {decode_col:>18}"
+            f" {fmt(r['ttft_ms'],    '8.1f')}"
+            f" {fmt(r['tpot_ms'],    '8.1f')}"
+            f" {fmt(r['latency_ms'], '9.1f')}"
+            f" {fmt(r['weight_gib'], '8.2f')}"
+            f" {fmt(r['peak_vram'],  '8.2f')}"
+        )
+    print("─" * 120)
+
+    # ── Table 2: Quality ──────────────────────────────────────────────────────
+    print("\nTABLE 2 — Quality")
+    print("─" * 70)
+    print(f"{'Model':<22} {'Quant':<8} {'PPL↓':>8} {'HellaSwag↑':>12} {'Winogrande↑':>13}")
+    print(f"{'':22} {'':8} {'':>8} {'(%)':>12} {'(%)':>13}")
+    print("─" * 70)
+
+    prev_model = None
+    for r in rows:
+        if r["model"] != prev_model and prev_model is not None:
+            print()
+        prev_model = r["model"]
+        idx = rows.index(r)
+        is_first = idx == 0 or rows[idx-1]["model"] != r["model"]
+        print(
+            f"{r['model'] if is_first else '':22}"
+            f" {r['quant']:<8}"
+            f" {fmt(r['ppl'],        '8.2f')}"
+            f" {fmt(r['hellaswag'],  '12.2f')}"
+            f" {fmt(r['winogrande'], '13.2f')}"
+        )
+    print("─" * 70)
+
+    # ── LaTeX: Quality table ─────────────────────────────────────────────────
+    print()
+    print(r"""\begin{table}[t]
+  \centering
+  \caption{%
+    Model quality metrics at multiple quantization levels.
+    \textbf{PPL} = perplexity on the Wikitext-2 test set
+    (lower is better).
+    \textbf{HellaSwag} = accuracy on 400 commonsense-NLI tasks from the
+    HellaSwag validation set (higher is better).
+    \textbf{Winogrande} = accuracy on 1{,}267 debiased pronoun-resolution
+    tasks (higher is better).
+    Both accuracy benchmarks are evaluated via log-likelihood ranking.%
+  }
+  \label{tab:llamacpp_quality}
+  \begin{tabular}{@{} l l r rr @{}}
+    \toprule
+    \textbf{Model} & \textbf{Quant} &
+    \textbf{PPL\,$\downarrow$} &
+    \textbf{HellaSwag (\%)\,$\uparrow$} &
+    \textbf{Winogrande (\%)\,$\uparrow$} \\""")
+
+    prev_model = None
+    for r in rows:
+        idx = rows.index(r)
+        is_first = idx == 0 or rows[idx-1]["model"] != r["model"]
+        if is_first:
+            print(r"    \midrule")
+
+        quant = r["quant"].replace("_", r"\_")
+        name_col = r["model"] if is_first else " " * len(r["model"])
+
+        if r["ppl"] is not None and r["ppl_std"] is not None:
+            ppl_str = f"${r['ppl']:.2f}\\pm{r['ppl_std']:.2f}$"
+        elif r["ppl"] is not None:
+            ppl_str = f"{r['ppl']:.2f}"
+        else:
+            ppl_str = "---"
+
+        hs = f"{r['hellaswag']:.2f}" if r["hellaswag"] is not None else "---"
+        wg = f"{r['winogrande']:.2f}" if r["winogrande"] is not None else "---"
+
+        print(f"    {name_col} & {quant} & {ppl_str} & {hs} & {wg} \\\\")
+
+    print(r"""    \bottomrule
+  \end{tabular}
+\end{table}""")
+
+    # ── LaTeX: Speed & Memory table ──────────────────────────────────────────
+    print()
+    print(r"""\begin{table*}[t]
+  \centering
+  \caption{%
+    Inference speed and memory usage for three open-weight LLMs at multiple
+    quantization levels, measured on NVIDIA~L40S GPU
+    using llama.cpp.
+    \textbf{Prefill} = prompt-processing throughput at 512 input tokens
+    (PP512, tokens/s);
+    \textbf{Decode} = text-generation throughput at 128 output tokens
+    (TG128, tokens/s);
+    \textbf{TTFT} = time-to-first-token;
+    \textbf{TPOT} = time-per-output-token;
+    \textbf{Latency} = TTFT\,+\,TPOT (mean of 3 streaming runs,
+    512-token prompt, 128 output tokens, temperature~0);
+    \textbf{Weight} = model-weight VRAM footprint;
+    \textbf{Peak} = maximum VRAM during benchmark.%
+  }
+  \label{tab:llamacpp_speed_memory}
+  \resizebox{\linewidth}{!}{%
+  \begin{tabular}{@{} l l rr rrr rr @{}}
+    \toprule
+    \multirow{2}{*}{\textbf{Model}} &
+    \multirow{2}{*}{\textbf{Quant}} &
+    \multicolumn{2}{c}{\textbf{Throughput (t/s)}} &
+    \multicolumn{3}{c}{\textbf{Latency (ms)}} &
+    \multicolumn{2}{c}{\textbf{VRAM (GiB)}} \\
+    \cmidrule(lr){3-4}\cmidrule(lr){5-7}\cmidrule(lr){8-9}
+    & &
+    \textbf{Prefill} & \textbf{Decode} &
+    \textbf{TTFT}   & \textbf{TPOT}  & \textbf{Total} &
+    \textbf{Weight} & \textbf{Peak}  \\""")
+
+    prev_model = None
+    for r in rows:
+        idx = rows.index(r)
+        is_first = idx == 0 or rows[idx-1]["model"] != r["model"]
+        if is_first:
+            print(r"    \midrule")
+
+        quant = r["quant"].replace("_", r"\_")
+        name_col = r["model"] if is_first else " " * len(r["model"])
+
+        if r["prefill_ts"] is not None and r["prefill_std"] is not None:
+            prefill_str = f"${r['prefill_ts']:.0f}\\pm{r['prefill_std']:.0f}$"
+        elif r["prefill_ts"] is not None:
+            prefill_str = f"{r['prefill_ts']:.0f}"
+        else:
+            prefill_str = "---"
+
+        if r["decode_ts"] is not None and r["decode_std"] is not None:
+            decode_str = f"${r['decode_ts']:.1f}\\pm{r['decode_std']:.1f}$"
+        elif r["decode_ts"] is not None:
+            decode_str = f"{r['decode_ts']:.1f}"
+        else:
+            decode_str = "---"
+
+        ttft = f"{r['ttft_ms']:.1f}" if r["ttft_ms"] is not None else "---"
+        tpot = f"{r['tpot_ms']:.2f}" if r["tpot_ms"] is not None else "---"
+        lat = f"{r['latency_ms']:.1f}" if r["latency_ms"] is not None else "---"
+        wt = f"{r['weight_gib']:.2f}" if r["weight_gib"] is not None else "---"
+        pk = f"{r['peak_vram']:.2f}" if r["peak_vram"] is not None else "---"
+
+        print(
+            f"    {name_col} & {quant} & "
+            f"{prefill_str} & {decode_str} & "
+            f"{ttft} & {tpot} & {lat} & "
+            f"{wt} & {pk} \\\\"
+        )
+
+    print(r"""    \bottomrule
+  \end{tabular}%
+  }
+\end{table*}""")
+
+
+if __name__ == "__main__":
+    main()

run_benchmark.sh

@@ -0,0 +1,184 @@
+#!/usr/bin/env bash
+# run_benchmark.sh — run all llama.cpp benchmarks for 3 LLMs × 4 quants
+#
+# Produces per-combination result files in the same directory as this script:
+#   {prefix}_bench.json    — llama-bench throughput + model size
+#   {prefix}_vram.log      — nvidia-smi dmon (raw, parsed later)
+#   {prefix}_ttft.json     — TTFT / TPOT from llama-server stream
+#   {prefix}_ppl.txt       — perplexity on wikitext-2
+#   {prefix}_hellaswag.txt — HellaSwag accuracy (400 tasks)
+#   {prefix}_winogrande.txt— Winogrande accuracy (all tasks)
+#
+# Run with:  bash results/run_benchmark.sh
+# Skip already-done runs: set SKIP_EXISTING=1 (default)
+# ─────────────────────────────────────────────────────────────────────────────
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+BENCH="$ROOT/build/bin/llama-bench"
+PPL="$ROOT/build/bin/llama-perplexity"
+
+WIKI="$ROOT/wikitext-2-raw/wiki.test.raw"
+HELLASWAG="$ROOT/hellaswag_val_400.txt"
+WINOGRANDE="$ROOT/winogrande-debiased-eval.csv"
+TTFT_SCRIPT="$SCRIPT_DIR/measure_ttft.py"
+
+SKIP_EXISTING="${SKIP_EXISTING:-1}"    # set to 0 to re-run everything
+SKIP_WINOGRANDE="${SKIP_WINOGRANDE:-0}" # set to 1 to skip Winogrande entirely
+DEVICE="${DEVICE:-CUDA0}"              # single GPU to use (CUDA0 = GPU 0)
+GPU_IDX=0                              # nvidia-smi GPU index matching DEVICE
+NGL=99                                 # GPU layers
+PPL_CTX=512                            # context window for perplexity
+PPL_CHUNKS=400                         # chunks to evaluate (~488 total); all chunks for full accuracy
+PPL_BATCH=8192                         # n_batch for perplexity: n_seq = PPL_BATCH/PPL_CTX
+                                       # 8192/512 = 16 chunks processed in parallel per pass
+HELLASWAG_TASKS=400                    # subset file already contains exactly 400 tasks
+
+# ── Model paths ───────────────────────────────────────────────────────────────
+HF_LLAMA="/home/user1/.cache/huggingface/hub/models--bartowski--Meta-Llama-3.1-8B-Instruct-GGUF/snapshots/bf5b95e96dac0462e2a09145ec66cae9a3f12067"
+HF_QWEN="/home/user1/.cache/huggingface/hub/models--bartowski--Qwen2.5-7B-Instruct-GGUF/snapshots/8911e8a47f92bac19d6f5c64a2e2095bd2f7d031"
+HF_GEMMA="/home/user1/.cache/huggingface/hub/models--bartowski--gemma-2-9b-it-GGUF/snapshots/d731033f3dc4018261fd39896e50984d398b4ac5"
+
+declare -A MODEL   # MODEL[key] = path
+MODEL[llama-f16]="$ROOT/models/llama-3.1-8b-instruct-f16.gguf"
+MODEL[llama-Q8_0]="$HF_LLAMA/Meta-Llama-3.1-8B-Instruct-Q8_0.gguf"
+MODEL[llama-Q4_K_M]="$ROOT/models/llama-3.1-8b-instruct-Q4_K_M.gguf"
+MODEL[llama-Q2_K]="$HF_LLAMA/Meta-Llama-3.1-8B-Instruct-Q2_K.gguf"
+MODEL[qwen-f16]="$HF_QWEN/Qwen2.5-7B-Instruct-f16.gguf"
+MODEL[qwen-Q8_0]="$HF_QWEN/Qwen2.5-7B-Instruct-Q8_0.gguf"
+MODEL[qwen-Q4_K_M]="$HF_QWEN/Qwen2.5-7B-Instruct-Q4_K_M.gguf"
+MODEL[qwen-Q2_K]="$HF_QWEN/Qwen2.5-7B-Instruct-Q2_K.gguf"
+MODEL[gemma-f16]="$ROOT/models/gemma-2-9b-it-f16.gguf"
+MODEL[gemma-Q8_0]="$ROOT/models/gemma-2-9b-it-Q8_0.gguf"
+MODEL[gemma-Q4_K_M]="$ROOT/models/gemma-2-9b-it-Q4_K_M.gguf"
+MODEL[gemma-Q2_K]="$HF_GEMMA/gemma-2-9b-it-Q2_K.gguf"
+# Result file prefix for each key (matches existing naming convention)
+declare -A PREFIX
+PREFIX[llama-f16]="llama-3.1-8b-instruct-f16"
+PREFIX[llama-Q8_0]="llama-3.1-8b-instruct-Q8_0"
+PREFIX[llama-Q4_K_M]="llama-3.1-8b-instruct-Q4_K_M"
+PREFIX[llama-Q2_K]="llama-3.1-8b-instruct-Q2_K"
+PREFIX[qwen-f16]="qwen2.5-7b-instruct-f16"
+PREFIX[qwen-Q8_0]="qwen2.5-7b-instruct-Q8_0"
+PREFIX[qwen-Q4_K_M]="qwen2.5-7b-instruct-Q4_K_M"
+PREFIX[qwen-Q2_K]="qwen2.5-7b-instruct-Q2_K"
+PREFIX[gemma-f16]="gemma-2-9b-it-f16"
+PREFIX[gemma-Q8_0]="gemma-2-9b-it-Q8_0"
+PREFIX[gemma-Q4_K_M]="gemma-2-9b-it-Q4_K_M"
+PREFIX[gemma-Q2_K]="gemma-2-9b-it-Q2_K"
+KEYS=(
+    llama-f16  llama-Q8_0  llama-Q4_K_M  llama-Q2_K
+    qwen-f16   qwen-Q8_0   qwen-Q4_K_M   qwen-Q2_K
+    gemma-f16  gemma-Q8_0  gemma-Q4_K_M  gemma-Q2_K
+)
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+log()  { echo "[$(date '+%H:%M:%S')] $*"; }
+skip() { [[ "$SKIP_EXISTING" == "1" && -s "$1" ]]; }
+
+# ── Main loop ─────────────────────────────────────────────────────────────────
+for KEY in "${KEYS[@]}"; do
+    MODEL_PATH="${MODEL[$KEY]}"
+    PFX="$SCRIPT_DIR/${PREFIX[$KEY]}"
+
+    if [[ ! -f "$MODEL_PATH" ]]; then
+        echo "WARNING: model not found, skipping $KEY: $MODEL_PATH"
+        continue
+    fi
+
+    log "═══ $KEY ═══"
+
+    # ── 1. llama-bench (throughput + model size) with VRAM monitoring ─────────
+    BENCH_OUT="$PFX"_bench.json
+    VRAM_OUT="$PFX"_vram.log
+    if skip "$BENCH_OUT"; then
+        log "  [bench] skipping (exists)"
+    else
+        log "  [bench] starting nvidia-smi dmon (GPU $GPU_IDX only)..."
+        nvidia-smi dmon -s m -d 1 -i "$GPU_IDX" > "$VRAM_OUT" &
+        DMON_PID=$!
+
+        log "  [bench] running llama-bench (single GPU: $DEVICE)..."
+        "$BENCH" \
+            -m "$MODEL_PATH" \
+            -ngl "$NGL" \
+            -dev "$DEVICE" \
+            -p 512 -n 128 -r 3 \
+            -o json \
+            > "$BENCH_OUT"
+
+        kill "$DMON_PID" 2>/dev/null && wait "$DMON_PID" 2>/dev/null || true
+        log "  [bench] done → $BENCH_OUT"
+    fi
+
+    # ── 2. TTFT / TPOT via llama-server ──────────────────────────────────────
+    TTFT_OUT="$PFX"_ttft.json
+    if skip "$TTFT_OUT"; then
+        log "  [ttft] skipping (exists)"
+    else
+        log "  [ttft] running measure_ttft.py (single GPU: $DEVICE)..."
+        python3 "$TTFT_SCRIPT" -m "$MODEL_PATH" --device "$DEVICE" \
+            > "$TTFT_OUT" \
+            2> "$PFX"_ttft.log
+        log "  [ttft] done → $TTFT_OUT"
+    fi
+
+    # ── 3. Perplexity (wikitext-2, fixed context for cross-model comparability)
+    PPL_OUT="$PFX"_ppl.txt
+    if skip "$PPL_OUT"; then
+        log "  [ppl] skipping (exists)"
+    else
+        log "  [ppl] running llama-perplexity (ctx=$PPL_CTX, chunks=$PPL_CHUNKS, batch=$PPL_BATCH, GPU: $DEVICE)..."
+        "$PPL" \
+            -m "$MODEL_PATH" \
+            -ngl "$NGL" \
+            -dev "$DEVICE" \
+            -f "$WIKI" \
+            -c "$PPL_CTX" \
+            -b "$PPL_BATCH" \
+            --chunks "$PPL_CHUNKS" \
+            2>&1 | grep "^Final estimate" | tail -1 > "$PPL_OUT"
+        log "  [ppl] done → $PPL_OUT"
+    fi
+
+    # ── 4. HellaSwag accuracy ─────────────────────────────────────────────────
+    HS_OUT="$PFX"_hellaswag.txt
+    if skip "$HS_OUT"; then
+        log "  [hellaswag] skipping (exists)"
+    else
+        log "  [hellaswag] running ($HELLASWAG_TASKS tasks, GPU: $DEVICE)..."
+        "$PPL" \
+            -m "$MODEL_PATH" \
+            -ngl "$NGL" \
+            -dev "$DEVICE" \
+            -f "$HELLASWAG" \
+            --hellaswag \
+            --hellaswag-tasks "$HELLASWAG_TASKS" \
+            2>&1 | grep -E "^[0-9]+[[:space:]]" | tail -1 > "$HS_OUT"
+        log "  [hellaswag] done → $HS_OUT"
+    fi
+
+    # ── 5. Winogrande accuracy ────────────────────────────────────────────────
+    WG_OUT="$PFX"_winogrande.txt
+    if [[ "$SKIP_WINOGRANDE" == "1" ]]; then
+        log "  [winogrande] skipped (SKIP_WINOGRANDE=1)"
+    elif skip "$WG_OUT"; then
+        log "  [winogrande] skipping (exists)"
+    else
+        log "  [winogrande] running (GPU: $DEVICE)..."
+        "$PPL" \
+            -m "$MODEL_PATH" \
+            -ngl "$NGL" \
+            -dev "$DEVICE" \
+            -f "$WINOGRANDE" \
+            --winogrande \
+            2>&1 | grep -E "^[0-9]+[[:space:]]" | tail -1 > "$WG_OUT"
+        log "  [winogrande] done → $WG_OUT"
+    fi
+
+    log "  ✓ $KEY complete"
+done
+
+log "All benchmarks done. Run: python3 $SCRIPT_DIR/parse_results.py"