Re-export with public ExecuTorch 1.5.1 (recipe in export/)

README.md

@@ -20,8 +20,8 @@ the visitor's GPU. It powers the corresponding demo in the ExecuTorch WebGPU Pla
 
 - **Base model:** [openai/whisper-base](https://huggingface.co/openai/whisper-base)
 - **Format:** ExecuTorch `.pte` programs delegated to the WebGPU backend
-- **Quantization:** int8 token embeddings; other graphs as exported
-- **Total size:** 158.3 MB
+- **Quantization:** mixed: int8 output layer (int8 per-channel weights, int8 activations with a calibrated static scale) and int8 token-embedding table; mel front end, encoder and decoder in fp32
+- **Total size:** 229.6 MB
 
 > **Note:** OpenAI released Whisper's code under MIT; the weights are distributed under Apache-2.0, as on the upstream Hugging Face model card.
 
@@ -44,28 +44,34 @@ Accuracy varies by language, accent and recording conditions, and the model can
 
 ## What changed in this conversion
 
-- Token embeddings quantized to int8
-- Log-mel front end, encoder, cross-attention KV, decoder and LM head exported as separate programs for streaming decoding
+- Exported as six programs (mel front end, encoder, cross-attention K/V, two decoder forms, LM head); this repo ships the five used for streaming decoding. The full-recompute decoder (`whisper_decoder_split.pte`) is built by the recipe but not included
+- Mel front end, encoder, cross-attention K/V projections and decoder run in fp32
+- LM head: int8 weights (per output channel, symmetric) and int8 activations with a static per-tensor scale calibrated on 3 LibriSpeech clips that are not part of the evaluation set
+- Token embedding table stored as int8 per row (row absmax / 127) with fp32 scales; the positional table is fp32
+- Log-mel normalization runs on the host, between `whisper_mel.pte` (power mel spectrogram) and `whisper_encoder.pte`
+- The LM head is padded from 51,865 to 51,872 outputs; the 7 padding logits are -1e9
+- On 70 short clips from the LibriSpeech clean validation set, greedy transcripts have the same word error rate as transformers fp32 greedy decoding (8.42%), and 54 of 70 are token-identical to it. Only English transcription was tested
 
 ## Inputs and outputs
 
-- 16 kHz mono audio in Whisper's 30-second windows
-- `whisper_mel.pte`: audio to log-mel spectrogram; `whisper_encoder.pte`: spectrogram to audio features; `whisper_cross_kv.pte`: features to cross-attention keys and values
-- `whisper_decode_stream.pte` / `whisper_decoder_split.pte` with `whisper_lmhead.pte`: token-by-token decoding; token text from `vocab.json`
+- 16 kHz mono audio in windows of up to 30 s: zero-pad to 480,000 samples, reflect-pad 200 samples on each side, and cut 3000 frames of 400 samples at hop 160
+- `whisper_mel.pte`: frames `[1,3000,400]` -> power mel spectrogram `[1,3000,80]` (Hann window, DFT and mel filters inside the program). On the host: `x = log10(max(p, 1e-10))`, `x = max(x, max(x) - 8)`, `x = (x + 4) / 4`, then transpose to `[1,80,3000]`
+- `whisper_encoder.pte`: log-mel `[1,80,3000]` -> hidden states `[1,1500,512]`. `whisper_cross_kv.pte`: hidden states -> 12 tensors `[1,8,1500,64]` (k0, v0, ..., k5, v5), computed once per window
+- `whisper_decode_stream.pte`: `forward(embedding [1,1,512], input_pos int64 [1], 12 cross K/V tensors)` -> hidden `[1,1,512]`, one token per call; the self-attention cache (448 positions) lives inside the program. `whisper_lmhead.pte`: hidden -> logits `[1,1,51872]`; take the argmax over the first 51,865
+- Embedding input: row `id` of `whisper_embed.i8.bin` (int8 [51865,512]) times `whisper_embed.scale.f32.bin[id]` (float32 [51865]), plus row `p` of `whisper_pos_embed.f32.bin` (float32 [448,512]). English prefix: 50258, 50259, 50359, 50363; stop at 50257. Token text from `vocab.json`
 
 ## Files
 
 | File | Size | SHA-256 |
 |---|---|---|
 | `vocab.json` | 816.0 KB | `8f680bba319e01a6…` |
-| `whisper_cross_kv.pte` | 1.7 MB | `9ade21df20193271…` |
-| `whisper_decode_stream.pte` | 22.6 MB | `9b77ad9d5e003b06…` |
-| `whisper_decoder_split.pte` | 13.1 MB | `84d9427851420bf7…` |
+| `whisper_cross_kv.pte` | 12.0 MB | `6e8078924168c21a…` |
+| `whisper_decode_stream.pte` | 85.1 MB | `bc2f33ad7aa16405…` |
 | `whisper_embed.i8.bin` | 25.3 MB | `bc7f8d8336ad935e…` |
 | `whisper_embed.scale.f32.bin` | 202.6 KB | `1f58851911611b96…` |
-| `whisper_encoder.pte` | 78.6 MB | `951972490d33f680…` |
-| `whisper_lmhead.pte` | 14.4 MB | `1dfce892767b535b…` |
-| `whisper_mel.pte` | 696.8 KB | `d0b2759497debae4…` |
+| `whisper_encoder.pte` | 78.6 MB | `841e7702ba8fa735…` |
+| `whisper_lmhead.pte` | 25.9 MB | `68577fa240d29923…` |
+| `whisper_mel.pte` | 694.3 KB | `7cae318294879584…` |
 | `whisper_pos_embed.f32.bin` | 896.0 KB | `88fa1cdbf2b06f86…` |
 
 Full checksums are in `manifest.json`. The playground verifies them after download.
@@ -73,8 +79,9 @@ Full checksums are in `manifest.json`. The playground verifies them after downlo
 ## Running it
 
 These programs were exported with the ExecuTorch WebGPU backend
-([backends/webgpu](https://github.com/pytorch/executorch/tree/main/backends/webgpu)) and validated with the
-WebAssembly runtime build used by the ExecuTorch WebGPU Playground (launching soon on [executorch.ai](https://executorch.ai)). That runtime build is not published yet; until it is,
+([backends/webgpu](https://github.com/pytorch/executorch/tree/main/backends/webgpu)) and run in a browser (headless Chromium, WebGPU on SwiftShader) with a development build of the ExecuTorch
+WebGPU WebAssembly runtime, where every program matched the CPU results (max abs error 1.6e-3 or less) and 3 test
+transcripts were token-identical to the CPU pipeline. That runtime build is not published yet; until it is,
 the playground is the supported way to run them. It downloads these files once, caches them in the browser,
 and runs everything locally.
 
@@ -82,8 +89,10 @@ Requirements: a browser with WebGPU enabled.
 
 ## Provenance
 
-- Converted from the upstream checkpoint by the ExecuTorch team with the WebGPU export path.
-- A reproducible export recipe will be published alongside the open-source ExecuTorch WebGPU runtime.
+- **Upstream:** `openai/whisper-base` at revision `e37978b90ca9030d5170a5c07aadb050351a65bb` (official)
+- **Exported with:** executorch 1.5.1+cpu, torch 2.14.1+cpu, torchao 0.18.0+cpu, transformers 5.19.0 (executorch git `3b6068392324`)
+- **Reproduce:** `python recipes/whisper-base.py --out out/whisper-base/fp32dec-lmq8 --precision fp32dec-lmq8` (recipe in `export/`)
+- Re-running the recipe produces byte-identical files.
 
 ## Citation
 

export/_common.py

@@ -0,0 +1,330 @@
+"""Shared helpers for the ExecuTorch WebGPU export recipes in this directory.
+
+Each recipe builds an eager model from a pinned upstream revision and calls
+`export_vision` (or its own LLM path), which writes:
+
+  <out>/<name>_webgpu.pte    program lowered with WebGPUPartitioner (delegate id "VulkanBackend")
+  <out>/<name>_portable.pte  same exported graph without a delegate, for CPU validation only
+  <out>/recipe.json          upstream id + revision, versions, shapes, dtype, command line
+  <out>/validation.json      eager vs exported-program vs portable .pte (and goldens, if given)
+"""
+
+import hashlib
+import io
+import json
+import platform
+import shlex
+import sys
+import urllib.request
+import zipfile
+from pathlib import Path
+
+import numpy as np
+import torch
+
+PROXY_HINT = (
+    "set https_proxy if the machine needs a proxy for huggingface.co / pypi.org"
+)
+
+
+def versions():
+    import executorch
+    import torchao
+    from executorch.version import git_version
+
+    out = {
+        "python": platform.python_version(),
+        "torch": torch.__version__,
+        "torchao": torchao.__version__,
+        "executorch": getattr(executorch, "__version__", None)
+        or __import__("executorch.version").version.__version__,
+        "executorch_git": git_version,
+    }
+    try:
+        import transformers
+
+        out["transformers"] = transformers.__version__
+    except ImportError:
+        pass
+    try:
+        import huggingface_hub
+
+        out["huggingface_hub"] = huggingface_hub.__version__
+    except ImportError:
+        pass
+    return out
+
+
+def sha256_file(path):
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for chunk in iter(lambda: fh.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def hf_file(repo_id, filename, revision, expected_sha256=None, cache_dir=None):
+    from huggingface_hub import hf_hub_download
+
+    path = hf_hub_download(
+        repo_id=repo_id, filename=filename, revision=revision, cache_dir=cache_dir
+    )
+    digest = sha256_file(path)
+    if expected_sha256 and digest != expected_sha256:
+        sys.exit(
+            f"{repo_id}@{revision}:{filename} sha256 {digest} != {expected_sha256}"
+        )
+    return Path(path), digest
+
+
+def pypi_wheel_member(url, expected_sha256, member):
+    """Read one file out of a PyPI wheel, verifying the wheel's sha256."""
+    with urllib.request.urlopen(url, timeout=120) as resp:
+        blob = resp.read()
+    digest = hashlib.sha256(blob).hexdigest()
+    if digest != expected_sha256:
+        sys.exit(f"{url}: sha256 {digest} != {expected_sha256} ({PROXY_HINT})")
+    with zipfile.ZipFile(io.BytesIO(blob)) as zf:
+        return zf.read(member).decode()
+
+
+def scrub(text, out_dir):
+    """Replace machine-specific paths so recipe.json can ship with the model."""
+    text = text.replace(str(Path(out_dir).resolve()), "<out>")
+    text = text.replace(str(Path(__file__).resolve().parent), "recipes")
+    return text.replace(str(Path.home()), "~")
+
+
+def command_line(out_dir):
+    argv = [f"recipes/{Path(sys.argv[0]).name}", *sys.argv[1:]]
+    args = []
+    for a in argv:
+        if a.startswith("/") or a.startswith("."):
+            a = scrub(str(Path(a).resolve()), out_dir)
+        args.append(a)
+    return scrub(" ".join(["python", *(shlex.quote(a) for a in args)]), out_dir)
+
+
+def lower_webgpu(ep):
+    from executorch.backends.webgpu.partitioner import WebGPUPartitioner
+    from executorch.exir import to_edge_transform_and_lower
+
+    return to_edge_transform_and_lower(
+        ep, partitioner=[WebGPUPartitioner()]
+    ).to_executorch()
+
+
+def lower_portable(ep):
+    from executorch.exir import to_edge_transform_and_lower
+
+    return to_edge_transform_and_lower(ep).to_executorch()
+
+
+def delegate_summary(pte_bytes):
+    """Non-delegated kernels and per-delegate op histograms of a serialized program."""
+    import collections
+
+    from executorch.backends.vulkan.serialization.vulkan_graph_serialize import (
+        extract_vk_flatbuffer,
+        flatbuffer_to_vk_graph,
+    )
+    from executorch.exir._serialize._program import deserialize_pte_binary
+
+    pte = deserialize_pte_binary(pte_bytes)
+    prog = pte.program if hasattr(pte, "program") else pte
+    seg_base = int.from_bytes(pte_bytes[24:32], "little")
+    plan = prog.execution_plan[0]
+    ops = [f"{o.name}.{o.overload}" for o in plan.operators]
+    kernels = collections.Counter()
+    for chain in plan.chains:
+        for ins in chain.instructions:
+            if type(ins.instr_args).__name__ == "KernelCall":
+                kernels[ops[ins.instr_args.op_index]] += 1
+    delegates = []
+    for d in plan.delegates:
+        proc = d.processed
+        if proc.location.name == "INLINE":
+            blob = prog.backend_delegate_data[proc.index].data
+        else:
+            seg = prog.segments[proc.index]
+            blob = pte_bytes[seg_base + seg.offset : seg_base + seg.offset + seg.size]
+        g = flatbuffer_to_vk_graph(extract_vk_flatbuffer(blob))
+        delegates.append(
+            {
+                "id": d.id,
+                "ops": dict(collections.Counter(c.name for c in g.chain)),
+                "inputs": len(g.input_ids),
+                "outputs": len(g.output_ids),
+            }
+        )
+    return {"non_delegated_kernels": dict(kernels), "delegates": delegates}
+
+
+def compare(a, b):
+    a = np.asarray(a, dtype=np.float64).ravel()
+    b = np.asarray(b, dtype=np.float64).ravel()
+    n = min(a.size, b.size)
+    a, b = a[:n], b[:n]
+    cos = float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-30))
+    return {
+        "max_abs": float(np.max(np.abs(a - b))),
+        "mean_abs": float(np.mean(np.abs(a - b))),
+        "cosine": cos,
+    }
+
+
+def run_pte(pte_bytes, inputs):
+    from executorch.extension.pybindings.portable_lib import (
+        _load_for_executorch_from_buffer,
+    )
+
+    m = _load_for_executorch_from_buffer(pte_bytes)
+    return [
+        o.detach().numpy() if isinstance(o, torch.Tensor) else o
+        for o in m.forward(inputs)
+    ]
+
+
+def try_run_webgpu_pte_on_cpu(pte_bytes, inputs):
+    try:
+        return run_pte(pte_bytes, inputs), None
+    except Exception as e:  # noqa: BLE001 - the error text is the result
+        return None, f"{type(e).__name__}: {str(e).splitlines()[0][:300]}"
+
+
+def export_vision(
+    *,
+    name,
+    model,
+    example_input,
+    out_dir,
+    upstream,
+    extra_recipe,
+    golden=None,
+    output_index=None,
+):
+    """Export, lower, write both .pte files, recipe.json, and validation.json.
+
+    `golden` is an optional (input ndarray, output ndarray) pair; when its input
+    shape matches `example_input`, all paths are also compared against it.
+    `output_index` picks one tensor when the eager model returns a tuple.
+    """
+    out_dir = Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    torch.manual_seed(0)
+    model = model.eval()
+
+    class Wrapped(torch.nn.Module):
+        def __init__(self, m):
+            super().__init__()
+            self.m = m
+
+        def forward(self, x):
+            y = self.m(x)
+            return y[output_index] if output_index is not None else y
+
+    wrapped = Wrapped(model).eval()
+    with torch.no_grad():
+        ep = torch.export.export(wrapped, (example_input,), strict=False)
+        webgpu = lower_webgpu(ep)
+        portable = lower_portable(ep)
+
+    webgpu_path = out_dir / f"{name}_webgpu.pte"
+    portable_path = out_dir / f"{name}_portable.pte"
+    webgpu_path.write_bytes(webgpu.buffer)
+    portable_path.write_bytes(portable.buffer)
+
+    summary = delegate_summary(webgpu.buffer)
+    out_shape = list(ep.module()(example_input).shape)
+    recipe = {
+        "model": name,
+        "upstream": upstream,
+        "versions": versions(),
+        "export": {
+            "api": "torch.export.export(strict=False) -> to_edge_transform_and_lower(partitioner=[WebGPUPartitioner()]) -> to_executorch()",
+            "partitioner": "executorch.backends.webgpu.partitioner.WebGPUPartitioner() (default compile options; wraps VulkanPartitioner)",
+            "inputs": [
+                {
+                    "shape": list(example_input.shape),
+                    "dtype": "float32",
+                    "layout": "NCHW",
+                }
+            ],
+            "outputs": [{"shape": out_shape, "dtype": "float32"}],
+            "dtype": "float32",
+            "quantization": "none (fp32)",
+            **extra_recipe,
+        },
+        "files": {
+            webgpu_path.name: {
+                "bytes": webgpu_path.stat().st_size,
+                "sha256": sha256_file(webgpu_path),
+            },
+            portable_path.name: {
+                "bytes": portable_path.stat().st_size,
+                "sha256": sha256_file(portable_path),
+                "note": "CPU-only validation artifact (portable kernels, no delegate); not for release",
+            },
+        },
+        "graph": summary,
+        "command": command_line(out_dir),
+    }
+    (out_dir / "recipe.json").write_text(json.dumps(recipe, indent=2) + "\n")
+
+    # Validation on CPU.
+    gen = torch.Generator().manual_seed(1234)
+    rand_input = torch.rand(example_input.shape, generator=gen)
+    cases = {"random": rand_input}
+    if golden is not None and tuple(golden[0].shape) == tuple(example_input.shape):
+        cases["golden"] = torch.from_numpy(golden[0].copy())
+    report = {
+        "cpu_runtime": "executorch pybindings (portable_lib) from the pip wheel",
+        "cases": {},
+    }
+    webgpu_cpu_error = None
+    for label, x in cases.items():
+        with torch.no_grad():
+            eager = wrapped(x).numpy()
+            exported = ep.module()(x).numpy()
+        port = run_pte(portable.buffer, (x,))[0]
+        res = {
+            "exported_vs_eager": compare(exported, eager),
+            "portable_pte_vs_eager": compare(port, eager),
+        }
+        wg, err = try_run_webgpu_pte_on_cpu(webgpu.buffer, (x,))
+        if wg is not None:
+            res["webgpu_pte_vs_eager"] = compare(wg[0], eager)
+        else:
+            webgpu_cpu_error = err
+        if label == "golden":
+            ref = golden[1]
+            res["internal_golden_vs_eager"] = compare(eager, ref)
+            res["internal_golden_vs_portable_pte"] = compare(port, ref)
+            res["golden_note"] = (
+                "reference output from the internal goldens.manifest.json"
+            )
+        report["cases"][label] = res
+    report["webgpu_pte_on_cpu"] = (
+        "ran"
+        if webgpu_cpu_error is None
+        else f"not runnable on CPU pybindings: {webgpu_cpu_error}"
+    )
+    (out_dir / "validation.json").write_text(json.dumps(report, indent=2) + "\n")
+    print(
+        json.dumps(
+            {"recipe": recipe["files"], "graph": summary, "validation": report},
+            indent=2,
+        )
+    )
+    return ep, webgpu, portable
+
+
+def load_golden(manifest_path, key):
+    man = json.loads(Path(manifest_path).read_text())[key]["tensors"]
+    base = Path(manifest_path).parent
+
+    def ld(t):
+        return np.fromfile(base / t["file"], dtype=np.float32).reshape(t["shape"])
+
+    inp = man.get("input")
+    return ld(inp), ld(man["output"])

export/_whisper.py

@@ -0,0 +1,662 @@
+"""Whisper base building blocks for recipes/whisper-base.py.
+
+Everything here is built from the pinned openai/whisper-base checkpoint loaded through transformers
+(WhisperForConditionalGeneration); the program wrappers reuse its nn.Modules (weights are shared, not
+copied) and only re-express the forward pass so that it lowers to one WebGPU delegate per program.
+
+Program contract (same split and I/O as the playground's previous whisper-base export):
+
+  mel            forward(frames[1,3000,400] f32) -> power_mel[1,3000,80] f32
+                 frames: 30 s of 16 kHz audio, zero-padded to 480000 samples, reflect-padded by 200 on
+                 both ends, 3000 windows of 400 samples at hop 160 (= whisper.js buildFrames).
+                 power_mel = |rfft(hann_periodic * frame)|^2 @ mel_filters (no log; see host_log_mel).
+  encoder        forward(log_mel[1,80,3000] f32) -> encoder_hidden[1,1500,512] f32   (fp32 weights)
+  cross_kv       forward(encoder_hidden[1,1500,512]) -> 12 x [1,8,1500,64] f32, order k0,v0,...,k5,v5
+                 (per decoder layer: encoder_attn.k_proj / v_proj, heads-first [B,H,S,D])
+  decoder_split  forward(tok_embeds[1,64,512], k0, v0, ..., k5, v5) -> hidden[1,64,512]
+                 tok_embeds: token embeddings WITHOUT positions for positions 0..64 (zero rows beyond
+                 the live prefix); the program adds positions 0..63, runs causal self-attention over
+                 the 64 rows and returns final-LayerNorm hidden states (row p predicts token p+1).
+  decode_stream  forward(embed[1,1,512], input_pos[1] i64, k0, v0, ..., k5, v5) -> hidden[1,1,512]
+                 embed = token embedding + positional embedding of `input_pos` (added on the host);
+                 self-attention K/V cache [1,448,8,64] x 6 layers x {k,v} lives inside the program
+                 (mutable buffers owned by the delegate); feed positions 0,1,2,... in order.
+  lmhead         forward(hidden[1,1,512]) -> logits[1,1,51872]  (tied to decoder.embed_tokens; rows
+                 51865..51871 are padding with logit -1e9, see LMHeadProgram)
+
+Precision (whisper-base.py --precision):
+  q4   (previous-export parity) cross_kv / decoder_split / decode_stream / lmhead linears are 4-bit groupwise
+       weight-only (torchao IntxWeightOnlyConfig int4, group 64, symmetric, "affine" qparams ->
+       et_vk.linear_q4gsw); int8 token-embedding table. mel and encoder are fp32.
+  fp32 every program fp32 (aten.linear on 2-D views); fp32 token-embedding table.
+
+Host-side files (reproduced from the checkpoint by the recipe, consumed by the playground JS):
+  whisper_embed.i8.bin         int8 [51865,512]  round(embed_tokens / scale), scale = rowwise absmax/127  (q4)
+  whisper_embed.scale.f32.bin  f32  [51865]      the per-row scales                                       (q4)
+  whisper_embed.f32.bin        f32  [51865,512]  embed_tokens                                             (fp32)
+  whisper_pos_embed.f32.bin    f32  [448,512]    decoder.embed_positions.weight
+  vocab.json                   upstream tokenizer vocab (byte-level BPE, detokenization only)
+"""
+
+import copy
+import io
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+SAMPLE_RATE = 16000
+N_FFT = 400
+HOP = 160
+FRAMES = 3000
+N_SAMPLES = FRAMES * HOP
+PAD = N_FFT // 2
+N_FREQ = N_FFT // 2 + 1
+N_MELS = 80
+ENC_LEN = 1500
+D_MODEL = 512
+N_HEADS = 8
+HEAD_DIM = 64
+N_LAYERS = 6
+MAX_DEC = 64  # decoder_split rows; the playground's decode budget (prefix + generated)
+KV_LEN = 448  # decode_stream self-attention cache length (= max_target_positions)
+VOCAB = 51865
+VOCAB_PADDED = 51872  # lmhead rows (multiple of 8, = the previous export)
+PAD_LOGIT = -1e9
+
+TOK = {
+    "sot": 50258,
+    "eot": 50257,
+    "en": 50259,
+    "transcribe": 50359,
+    "notimestamps": 50363,
+}
+PREFIX_EN = [TOK["sot"], TOK["en"], TOK["transcribe"], TOK["notimestamps"]]
+
+
+# --------------------------------------------------------------------------------------------
+# Host-side math that the playground does in JS (kept here so validation runs the same steps).
+# --------------------------------------------------------------------------------------------
+
+
+def build_frames(pcm):
+    """Mirror of whisper.js buildFrames(): [3000, 400] float32 windows (no window function)."""
+    pcm = np.asarray(pcm, dtype=np.float32)
+    base = np.zeros(N_SAMPLES + 2 * PAD, dtype=np.float32)
+    n = min(pcm.size, N_SAMPLES)
+    base[PAD : PAD + n] = pcm[:n]
+    for i in range(PAD):
+        base[PAD - 1 - i] = base[PAD + 1 + i]
+        base[PAD + N_SAMPLES + i] = base[PAD + N_SAMPLES - 2 - i]
+    idx = np.arange(FRAMES)[:, None] * HOP + np.arange(N_FFT)[None, :]
+    return base[idx]
+
+
+def host_log_mel(power_mel):
+    """Host step between the mel and encoder programs (WhisperFeatureExtractor normalization).
+
+    power_mel [1,3000,80] (or [3000,80]) -> log_mel [1,80,3000]:
+      x = log10(max(p, 1e-10)); x = max(x, max(x) - 8); x = (x + 4) / 4; transpose.
+    float32 throughout (the JS equivalent uses Float32Array + Math.log10).
+    """
+    p = np.asarray(power_mel, dtype=np.float32).reshape(FRAMES, N_MELS)
+    x = np.log10(np.maximum(p, np.float32(1e-10))).astype(np.float32)
+    x = np.maximum(x, x.max() - np.float32(8.0))
+    x = ((x + np.float32(4.0)) / np.float32(4.0)).astype(np.float32)
+    return np.ascontiguousarray(x.T)[None]
+
+
+class HostTables:
+    """Token-embedding lookup as the playground JS does it, plus the files that carry the tables.
+
+    kind="int8": whisper_embed.i8.bin (int8 [51865,512], round(w / s)) + whisper_embed.scale.f32.bin
+                 (s = rowwise absmax / 127): byte-identical to the previous export's files.
+    kind="fp32": whisper_embed.f32.bin (fp32 [51865,512], the checkpoint's embed_tokens).
+    Both: whisper_pos_embed.f32.bin (fp32 [448,512], decoder.embed_positions)."""
+
+    def __init__(self, model, kind):
+        e = model.model.decoder.embed_tokens.weight.detach().float()
+        self.kind = kind
+        self.pos = model.model.decoder.embed_positions.weight.detach().float().numpy()
+        if kind == "int8":
+            scale = e.abs().amax(dim=1) / 127.0
+            self.table = torch.round(e / scale[:, None]).clamp(-127, 127).to(torch.int8).numpy()
+            self.scale = scale.numpy().astype(np.float32)
+        elif kind == "fp32":
+            self.table = e.numpy().astype(np.float32)
+            self.scale = None
+        else:
+            raise ValueError(kind)
+
+    def embed(self, ids, position=None):
+        e = self.table[ids].astype(np.float32)
+        if self.scale is not None:
+            e = e * self.scale[ids][..., None]
+        if position is not None:
+            e = e + self.pos[position]
+        return e.astype(np.float32)
+
+    def files(self):
+        out = {}
+        if self.kind == "int8":
+            out["whisper_embed.i8.bin"] = self.table.tobytes()
+            out["whisper_embed.scale.f32.bin"] = self.scale.astype("<f4").tobytes()
+        else:
+            out["whisper_embed.f32.bin"] = self.table.astype("<f4").tobytes()
+        out["whisper_pos_embed.f32.bin"] = self.pos.astype("<f4").tobytes()
+        return out
+
+
+# --------------------------------------------------------------------------------------------
+# Program wrappers.
+# --------------------------------------------------------------------------------------------
+
+
+def dft_mel_weights(feature_extractor):
+    """cos / -sin DFT rows with the periodic Hann window folded in, plus the HF mel filters."""
+    n = np.arange(N_FFT)
+    k = np.arange(N_FREQ)
+    window = 0.5 - 0.5 * np.cos(
+        2.0 * np.pi * n / N_FFT
+    )  # periodic Hann (torch / HF default)
+    ang = 2.0 * np.pi * ((k[:, None] * n[None, :]) % N_FFT) / N_FFT
+    wc = (np.cos(ang) * window[None, :]).astype(np.float32)
+    ws = (-np.sin(ang) * window[None, :]).astype(np.float32)
+    mel = np.asarray(feature_extractor.mel_filters, dtype=np.float64).T.astype(
+        np.float32
+    )
+    assert mel.shape == (N_MELS, N_FREQ), mel.shape
+    return torch.from_numpy(wc), torch.from_numpy(ws), torch.from_numpy(mel)
+
+
+class MelProgram(torch.nn.Module):
+    def __init__(self, feature_extractor):
+        super().__init__()
+        wc, ws, mel = dft_mel_weights(feature_extractor)
+        self.register_buffer("wc", wc)
+        self.register_buffer("ws", ws)
+        self.register_buffer("mel", mel)
+
+    def forward(self, frames):
+        x = frames.reshape(
+            FRAMES, N_FFT
+        )  # aten.linear on the WebGPU runtime is 2-D only
+        re = F.linear(x, self.wc)
+        im = F.linear(x, self.ws)
+        return F.linear(re * re + im * im, self.mel).reshape(1, FRAMES, N_MELS)
+
+
+def _heads(x, s):
+    """[s, 512] or [1, s, 512] -> [1, 8, s, 64]."""
+    return x.reshape(1, s, N_HEADS, HEAD_DIM).transpose(1, 2)
+
+
+def _merge(o, s):
+    """[1, 8, s, 64] -> [1, s, 512]."""
+    return o.transpose(1, 2).reshape(1, s, D_MODEL)
+
+
+def attention(q, k, v, mask, impl):
+    """q/k/v [1,H,S,D]; scale = 1/sqrt(64) = 0.125 (a power of two, so applying it to q as HF does
+    or to q.k as the kernels do is bit-identical)."""
+    if impl == "et_vk":
+        import executorch.backends.vulkan.custom_ops_lib  # noqa: F401  (torch.ops.et_vk.*)
+
+        return torch.ops.et_vk.sdpa(q, k, v, mask, None)
+    s = torch.matmul(q * 0.125, k.transpose(-2, -1))
+    if mask is not None:
+        s = s + mask
+    return torch.matmul(torch.softmax(s, dim=-1), v)
+
+
+class EncoderProgram(torch.nn.Module):
+    """HF WhisperEncoder forward re-expressed with 2-D fp32 linears.
+
+    attn="eager": matmul + softmax (lowered to aten.bmm/_softmax; activation memory is planned).
+    attn="et_vk": the fused et_vk.sdpa op (what the previous export used); on the public WebGPU
+    runtime each call allocates its own two [8,1500,1500] f32 scratch buffers (72 MB each).
+    """
+
+    def __init__(self, model, attn="eager"):
+        super().__init__()
+        self.enc = model.model.encoder
+        self.attn = attn
+
+    def forward(self, log_mel):
+        e = self.enc
+        x = F.gelu(e.conv1(log_mel))
+        x = F.gelu(e.conv2(x))  # [1, 512, 1500]
+        x = x.permute(0, 2, 1).reshape(ENC_LEN, D_MODEL) + e.embed_positions.weight
+        for layer in e.layers:
+            a = layer.self_attn
+            h = layer.self_attn_layer_norm(x)
+            q = _heads(a.q_proj(h), ENC_LEN)
+            k = _heads(a.k_proj(h), ENC_LEN)
+            v = _heads(a.v_proj(h), ENC_LEN)
+            o = attention(q, k, v, None, "et_vk" if self.attn == "et_vk" else "torch")
+            x = x + a.out_proj(o.transpose(1, 2).reshape(ENC_LEN, D_MODEL))
+            h = layer.final_layer_norm(x)
+            x = x + layer.fc2(F.gelu(layer.fc1(h)))
+        return e.layer_norm(x).reshape(1, ENC_LEN, D_MODEL)
+
+
+def _lin(m, x):
+    """nn.Linear that lowers on the public WebGPU runtime: fp32 aten.linear only accepts 2-D
+    inputs, so fp32 weights get a [-1, K] view; int4 (q4gsw) linears accept any rank and keep it."""
+    if type(m.weight.data) is torch.Tensor and x.dim() != 2:
+        return m(x.reshape(-1, x.shape[-1])).reshape(*x.shape[:-1], m.out_features)
+    return m(x)
+
+
+class CrossKVProgram(torch.nn.Module):
+    def __init__(self, decoder):
+        super().__init__()
+        self.layers = decoder.layers
+
+    def forward(self, enc):
+        out = []
+        for layer in self.layers:
+            a = layer.encoder_attn
+            out.append(_heads(_lin(a.k_proj, enc), ENC_LEN))
+            out.append(_heads(_lin(a.v_proj, enc), ENC_LEN))
+        return tuple(out)
+
+
+def _mlp(layer, x):
+    return x + _lin(layer.fc2, F.gelu(_lin(layer.fc1, layer.final_layer_norm(x))))
+
+
+def _cross(layer, x, k, v, s, impl):
+    a = layer.encoder_attn
+    h = layer.encoder_attn_layer_norm(x)
+    o = attention(_heads(_lin(a.q_proj, h), s), k, v, None, impl)
+    return x + _lin(a.out_proj, _merge(o, s))
+
+
+class DecoderSplitProgram(torch.nn.Module):
+    """Full-recompute decoder over MAX_DEC rows with a causal mask (no KV cache)."""
+
+    def __init__(self, decoder, attn="et_vk"):
+        super().__init__()
+        self.dec = decoder
+        self.attn = attn
+        self.register_buffer(
+            "pos", decoder.embed_positions.weight.detach()[:MAX_DEC].clone()
+        )
+        causal = torch.full((MAX_DEC, MAX_DEC), -1e30).triu(1)  # same fill as the previous export
+        # et_vk.sdpa on the WebGPU runtime requires the full [B, H, S_q, S_kv] mask.
+        self.register_buffer(
+            "mask", causal.expand(1, N_HEADS, MAX_DEC, MAX_DEC).contiguous()
+        )
+
+    def forward(self, tok_embeds, *cross_kv):
+        x = tok_embeds + self.pos
+        for i, layer in enumerate(self.dec.layers):
+            a = layer.self_attn
+            h = layer.self_attn_layer_norm(x)
+            q = _heads(_lin(a.q_proj, h), MAX_DEC)
+            k = _heads(_lin(a.k_proj, h), MAX_DEC)
+            v = _heads(_lin(a.v_proj, h), MAX_DEC)
+            o = attention(q, k, v, self.mask, self.attn)
+            x = x + _lin(a.out_proj, _merge(o, MAX_DEC))
+            x = _cross(
+                layer, x, cross_kv[2 * i], cross_kv[2 * i + 1], MAX_DEC, self.attn
+            )
+            x = _mlp(layer, x)
+        return self.dec.layer_norm(x)
+
+
+class DecodeStreamProgram(torch.nn.Module):
+    """One token per call; self-attention K/V cache [1,448,8,64] per layer kept in the program.
+
+    Self-attention uses llama.update_cache + llama.custom_sdpa (executorch.extension.llm.custom_ops),
+    which the Vulkan partitioner fuses into sdpa_with_kv_cache with an et_vk.select_as_symint
+    position. Cross-attention uses et_vk.sdpa (attn="et_vk") or matmul/softmax (attn="torch").
+    """
+
+    def __init__(self, decoder, attn="et_vk"):
+        super().__init__()
+        from executorch.extension.llm.custom_ops import custom_ops  # noqa: F401
+
+        self.dec = decoder
+        self.attn = attn
+        for i in range(N_LAYERS):
+            self.register_buffer(
+                f"k_cache_{i}",
+                torch.zeros(1, KV_LEN, N_HEADS, HEAD_DIM),
+                persistent=False,
+            )
+            self.register_buffer(
+                f"v_cache_{i}",
+                torch.zeros(1, KV_LEN, N_HEADS, HEAD_DIM),
+                persistent=False,
+            )
+
+    def reset(self):
+        for i in range(N_LAYERS):
+            getattr(self, f"k_cache_{i}").zero_()
+            getattr(self, f"v_cache_{i}").zero_()
+
+    def forward(self, embed, input_pos, *cross_kv):
+        pos = input_pos[0].item()
+        torch._check_is_size(pos)
+        torch._check(pos < KV_LEN)
+        x = embed
+        for i, layer in enumerate(self.dec.layers):
+            a = layer.self_attn
+            h = layer.self_attn_layer_norm(x)
+            q = _lin(a.q_proj, h).view(1, 1, N_HEADS, HEAD_DIM)
+            k = _lin(a.k_proj, h).view(1, 1, N_HEADS, HEAD_DIM)
+            v = _lin(a.v_proj, h).view(1, 1, N_HEADS, HEAD_DIM)
+            kc = getattr(self, f"k_cache_{i}")
+            vc = getattr(self, f"v_cache_{i}")
+            torch.ops.llama.update_cache(k, kc, pos)
+            torch.ops.llama.update_cache(v, vc, pos)
+            o = torch.ops.llama.custom_sdpa(q, kc, vc, pos, None, 0.0, True, None)
+            x = x + _lin(a.out_proj, o.reshape(1, 1, D_MODEL))
+            x = _cross(layer, x, cross_kv[2 * i], cross_kv[2 * i + 1], 1, self.attn)
+            x = _mlp(layer, x)
+        return self.dec.layer_norm(x)
+
+
+class LMHeadProgram(torch.nn.Module):
+    """Tied output projection. The vocab is padded to `pad_to` rows: executorch 1.5.1's q4gsw
+    lowering pads the scales to a multiple of 4 output channels and then fails its own shape
+    check for N = 51865, so N must already be a multiple of 4 (the previous export used 51872).
+    Padded rows have zero weights and a -1e9 bias, so they can never win an argmax."""
+
+    def __init__(self, model, pad_to=0):
+        super().__init__()
+        w = model.model.decoder.embed_tokens.weight.detach().clone()
+        n = w.shape[0]
+        b = torch.zeros(max(n, pad_to))
+        if pad_to and pad_to > n:
+            w = torch.cat([w, w.new_zeros(pad_to - n, w.shape[1])])
+            b[n:] = PAD_LOGIT
+        self.proj = torch.nn.Linear(D_MODEL, w.shape[0], bias=True)
+        self.proj.weight = torch.nn.Parameter(w, requires_grad=False)
+        self.proj.bias = torch.nn.Parameter(b, requires_grad=False)
+
+    def forward(self, hidden):
+        return _lin(self.proj, hidden)
+
+
+# --------------------------------------------------------------------------------------------
+# Quantization.
+# --------------------------------------------------------------------------------------------
+
+Q4_DESC = (
+    "torchao.quantization.quant_api.IntxWeightOnlyConfig(weight_dtype=torch.int4, "
+    "granularity=PerGroup(64), intx_choose_qparams_algorithm='affine') applied with quantize_ to "
+    "every nn.Linear of the program; symmetric, scale = group absmax / 7.5, q in [-8, 7]"
+)
+
+
+def quantize_q4(module, group_size=64):
+    from torchao.quantization.granularity import PerGroup
+    from torchao.quantization.quant_api import IntxWeightOnlyConfig, quantize_
+
+    quantize_(
+        module,
+        IntxWeightOnlyConfig(
+            weight_dtype=torch.int4,
+            granularity=PerGroup(group_size),
+            intx_choose_qparams_algorithm="affine",
+        ),
+    )
+    return module
+
+
+Q8_HEAD_DESC = (
+    "PT2E with executorch.backends.vulkan.quantizer.VulkanQuantizer: weights int8 per-output-channel "
+    "symmetric (PerChannelMinMaxObserver, the quantizer's own weight spec), input activation int8 "
+    "per-tensor affine STATIC (HistogramObserver) calibrated on lmhead inputs; lowers to "
+    "quantized_decomposed.quantize_per_tensor + et_vk.linear_q8ta_q8csw"
+)
+
+
+def q8_lmhead(lm, calib_hidden):
+    """Static-activation int8 x per-channel int8 lmhead (the only 8-bit linear executorch 1.5.1's
+    Vulkan lowering emits that the public WebGPU runtime registers). Returns the converted GraphModule
+    and the (input scale, zero point, dequantized weight) needed for an equivalent portable module."""
+    from executorch.backends.vulkan.quantizer.vulkan_quantizer import (
+        get_symmetric_quantization_config,
+        VulkanQuantizer,
+    )
+    from torchao.quantization.pt2e import HistogramObserver
+    from torchao.quantization.pt2e.quantize_pt2e import convert_pt2e, prepare_pt2e
+    from torchao.quantization.pt2e.quantizer import QuantizationConfig, QuantizationSpec
+
+    base = get_symmetric_quantization_config(is_dynamic=False, weight_bits=8)
+    act = QuantizationSpec(
+        dtype=torch.int8,
+        quant_min=-128,
+        quant_max=127,
+        qscheme=torch.per_tensor_affine,
+        is_dynamic=False,
+        observer_or_fake_quant_ctr=HistogramObserver,
+    )
+    cfg = QuantizationConfig(
+        input_activation=act, output_activation=None, weight=base.weight, bias=None, is_qat=False
+    )
+    with torch.no_grad():
+        gm = torch.export.export(lm.eval(), (calib_hidden[:1],), strict=False).module()
+        gm = prepare_pt2e(gm, VulkanQuantizer().set_global(cfg))
+        for i in range(calib_hidden.shape[0]):
+            gm(calib_hidden[i : i + 1])
+        gm = convert_pt2e(gm)
+    qp, wdq = None, None
+    for n in gm.graph.nodes:
+        if n.op != "call_function":
+            continue
+        name = str(n.target)
+        if "quantize_per_tensor" in name and "dequantize" not in name and qp is None:
+            qp = (float(n.args[1]), int(n.args[2]))
+        if "dequantize_per_channel" in name:
+            w = getattr(gm, n.args[0].target)
+            sc = getattr(gm, n.args[1].target)
+            wdq = (w.float() * sc.float()[:, None]).contiguous()
+    if qp is None or wdq is None:
+        raise RuntimeError("q8 lmhead: could not find the quantize/dequantize nodes")
+    return gm, qp, wdq
+
+
+class FakeQ8LMHead(torch.nn.Module):
+    """Portable-runtime equivalent of the q8 lmhead: per-tensor int8 fake-quant of the input, then
+    an fp32 linear on the dequantized int8 weights (same bias)."""
+
+    def __init__(self, lm, qp, wdq):
+        super().__init__()
+        self.scale, self.zp = qp
+        self.register_buffer("w", wdq)
+        self.register_buffer("b", lm.proj.bias.detach().clone())
+
+    def forward(self, hidden):
+        x = hidden.reshape(-1, D_MODEL)
+        q = torch.clamp(torch.round(x / self.scale) + self.zp, -128, 127)
+        x = (q - self.zp) * self.scale
+        return F.linear(x, self.w, self.b).reshape(*hidden.shape[:-1], self.w.shape[0])
+
+
+def word_errors(tokenizer, hyp_text, ref_text):
+    """(edits, reference words) after WhisperTokenizer.normalize (English text normalizer)."""
+    h = tokenizer.normalize(hyp_text).split()
+    r = tokenizer.normalize(ref_text).split()
+    d = list(range(len(r) + 1))
+    for i in range(1, len(h) + 1):
+        prev, d[0] = d[0], i
+        for j in range(1, len(r) + 1):
+            cur = d[j]
+            d[j] = min(d[j] + 1, d[j - 1] + 1, prev + (h[i - 1] != r[j - 1]))
+            prev = cur
+    return d[len(r)], len(r)
+
+
+def dequantized_copy(module):
+    """Same module with every quantized linear weight replaced by its fp32 dequantization.
+
+    Used only for the CPU portable .pte (the portable runtime has no torchao kernels); its numerics
+    are the q4 numerics (dequantize-then-fp32-matmul, as the q4gsw kernels compute)."""
+    m = copy.deepcopy(module)
+    for sub in m.modules():
+        if isinstance(sub, torch.nn.Linear) and hasattr(sub.weight, "dequantize"):
+            sub.weight = torch.nn.Parameter(
+                sub.weight.dequantize().float(), requires_grad=False
+            )
+    return m
+
+
+# --------------------------------------------------------------------------------------------
+# Speech sample.
+# --------------------------------------------------------------------------------------------
+
+
+def load_librispeech_dummy(parquet_path, max_sec=15.0, count=8, longer=False):
+    """First `count` clips (in file order) no longer than max_sec seconds, as 16 kHz float32.
+    longer=True selects the clips *longer* than max_sec instead (used only for calibration, so
+    calibration and evaluation clips never overlap)."""
+    import pyarrow.parquet as pq
+    import soundfile as sf
+
+    table = pq.read_table(parquet_path).to_pylist()
+    clips = []
+    for row in table:
+        audio, sr = sf.read(io.BytesIO(row["audio"]["bytes"]), dtype="float32")
+        if sr != SAMPLE_RATE:
+            raise ValueError(f"unexpected sample rate {sr}")
+        if audio.ndim != 1:
+            audio = audio.mean(axis=1)
+        if (audio.size / SAMPLE_RATE > max_sec) != longer:
+            continue
+        clips.append({"id": row["id"], "text": row["text"], "pcm": audio})
+        if len(clips) >= count:
+            break
+    return clips
+
+
+def seconds(pcm):
+    return round(len(pcm) / SAMPLE_RATE, 3)
+
+
+def isclose_report(a, b):
+    a = np.asarray(a, dtype=np.float64).ravel()
+    b = np.asarray(b, dtype=np.float64).ravel()
+    d = np.abs(a - b)
+    cos = float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-30))
+    return {
+        "max_abs": float(d.max()),
+        "mean_abs": float(d.mean()),
+        "max_rel_to_absmax": float(d.max() / (np.abs(b).max() + 1e-30)),
+        "cosine": cos,
+    }
+
+
+
+# --------------------------------------------------------------------------------------------
+# Lowered-graph inspection (what the WebGPU runtime will see).
+# --------------------------------------------------------------------------------------------
+
+
+def _vk_graphs(pte_bytes):
+    from executorch.backends.vulkan.serialization.vulkan_graph_serialize import (
+        extract_vk_flatbuffer,
+        flatbuffer_to_vk_graph,
+    )
+    from executorch.exir._serialize._program import deserialize_pte_binary
+
+    pte = deserialize_pte_binary(pte_bytes)
+    prog = pte.program if hasattr(pte, "program") else pte
+    seg_base = int.from_bytes(pte_bytes[24:32], "little")
+    out = []
+    for plan in prog.execution_plan:
+        for d in plan.delegates:
+            proc = d.processed
+            if proc.location.name == "INLINE":
+                blob = prog.backend_delegate_data[proc.index].data
+            else:
+                seg = prog.segments[proc.index]
+                blob = pte_bytes[seg_base + seg.offset : seg_base + seg.offset + seg.size]
+            out.append(flatbuffer_to_vk_graph(extract_vk_flatbuffer(blob)))
+    return prog, out
+
+
+def program_io(pte_bytes):
+    """Method names and their input/output tensor shapes + dtypes from the serialized program."""
+    from executorch.exir._serialize._program import deserialize_pte_binary
+
+    pte = deserialize_pte_binary(pte_bytes)
+    prog = pte.program if hasattr(pte, "program") else pte
+    res = {}
+    for plan in prog.execution_plan:
+
+        def desc(i):
+            v = plan.values[i].val
+            if hasattr(v, "sizes"):
+                return {"shape": list(v.sizes), "dtype": v.scalar_type.name.lower()}
+            return {"kind": type(v).__name__}
+
+        res[plan.name] = {
+            "inputs": [desc(i) for i in plan.inputs],
+            "outputs": [desc(i) for i in plan.outputs],
+        }
+    return res
+
+
+def vk_checks(pte_bytes, runtime_ops=None):
+    """Checks against constraints of the public WebGPU runtime's op implementations
+    (backends/webgpu/runtime/ops): op registered, aten.linear 2-D, et_vk.sdpa mask shape,
+    sdpa_with_kv_cache without mask / with causal, fp32 tensors only."""
+    _, graphs = _vk_graphs(pte_bytes)
+    problems, notes = [], {}
+    for g in graphs:
+        vals = [v.value for v in g.values]
+
+        def t(i):
+            v = vals[i]
+            return v if type(v).__name__ == "VkTensor" else None
+
+        dtypes = sorted({type(v).__name__ if type(v).__name__ != "VkTensor" else v.datatype.name for v in vals})
+        notes["value_kinds"] = dtypes
+        for op in g.chain:
+            name = op.name
+            if runtime_ops is not None and name not in runtime_ops:
+                problems.append(f"{name}: not registered in the WebGPU runtime op list")
+            a = op.args
+            if name == "aten.linear.default":
+                ri, rw = len(t(a[0]).dims), len(t(a[1]).dims)
+                notes.setdefault("aten.linear input ranks", set()).add(ri)
+                if ri != 2 or rw != 2:
+                    problems.append(f"aten.linear with input rank {ri}, weight rank {rw} (runtime needs 2-D)")
+            if name == "et_vk.sdpa.default":
+                q, k = t(a[0]), t(a[1])
+                m = t(a[3])
+                if m is not None:
+                    need = q.dims[0] * q.dims[1] * q.dims[2] * k.dims[2]
+                    got = int(np.prod(m.dims))
+                    if need != got:
+                        problems.append(f"et_vk.sdpa mask numel {got} != B*H*Sq*Skv {need}")
+                notes.setdefault("et_vk.sdpa q/k/mask", set()).add(
+                    (tuple(q.dims), tuple(k.dims), tuple(m.dims) if m is not None else None)
+                )
+            if name == "sdpa_with_kv_cache.default":
+                mask_kind = type(vals[a[7]]).__name__
+                causal = vals[a[9]]
+                if mask_kind != "Null":
+                    problems.append("sdpa_with_kv_cache with attn_mask (runtime rejects)")
+                if not (type(causal).__name__ == "Bool" and causal.bool_val):
+                    problems.append(f"sdpa_with_kv_cache is_causal={causal} (runtime needs true)")
+                notes.setdefault("sdpa_with_kv_cache q/k_cache", set()).add(
+                    (tuple(t(a[0]).dims), tuple(t(a[3]).dims), type(vals[a[5]]).__name__)
+                )
+            if name == "aten.convolution.default":
+                notes.setdefault("aten.convolution input/weight", set()).add(
+                    (tuple(t(a[0]).dims), tuple(t(a[1]).dims))
+                )
+        for v in vals:
+            if type(v).__name__ == "VkTensor" and v.datatype.name not in ("FLOAT32", "INT32", "INT64", "UINT8", "INT8"):
+                problems.append(f"tensor dtype {v.datatype.name}")
+                break
+    for k, v in list(notes.items()):
+        if isinstance(v, set):
+            notes[k] = sorted(str(x) for x in v)
+    return {"problems": problems, "ok": not problems, "notes": notes}

export/recipe.json

@@ -0,0 +1,844 @@
+{
+  "model": "whisper-base",
+  "precision": "fp32dec-lmq8",
+  "upstream": {
+    "model": "openai/whisper-base",
+    "revision": "e37978b90ca9030d5170a5c07aadb050351a65bb",
+    "official": true,
+    "license": "apache-2.0 (model card)",
+    "files_sha256": {
+      "model.safetensors": "07cadb9f25677c8d50df603e66a98fbd842cce45047139baeb16e6219a1e807b",
+      "config.json": "a153c53883a6799b6f056b4a8d1a515c9926d03994682ba88a7616618d7da0c1",
+      "generation_config.json": "444b3f636d2fff89dd9ecf549e2a085b61f7ff0fa0246d4628bac6a3b8cc9ba4",
+      "preprocessor_config.json": "9b5cd03a36fbb8a627c64d98a5b5b126ead95a77720723944487311f0110b666",
+      "vocab.json": "8f680bba319e01a653d2e8a5dbc17a9157179e0576e6ce74ce0c06356c6e24f9",
+      "tokenizer.json": "27fc476bfe7f17299480be2273fc0608e4d5a99aba2ab5dec5374b4482d1a566",
+      "tokenizer_config.json": "2a4c4281cf9f51ac6ccc406fdc711a087afe6530f671fa7b80953edc498275ce",
+      "merges.txt": "2df2990a395e35e8dfbc7511e08c12d56018d8d04691e0133e5d63b21e154dc6",
+      "normalizer.json": "bf1c507dc8724ca9cf9903640dacfb69dae2f00edee4f21ceba106a7392f26dd",
+      "added_tokens.json": "9715fd2243b6f06a5858b5e32950d2853f73dd5bc201aafcf76f5082a2d8acd1",
+      "special_tokens_map.json": "e67ae3a0aaa99abcd9f187138e12db1f65c16a14761c50ef10eef2c174a7a691"
+    },
+    "loader": "transformers.WhisperForConditionalGeneration.from_pretrained(dtype=float32, attn_implementation='eager')"
+  },
+  "versions": {
+    "python": "3.12.15+meta",
+    "torch": "2.14.1+cpu",
+    "torchao": "0.18.0+cpu",
+    "executorch": "1.5.1+cpu",
+    "executorch_git": "3b60683923245cf472b7323426920e15623ba361",
+    "transformers": "5.19.0",
+    "huggingface_hub": "2.2.0"
+  },
+  "export": {
+    "api": "torch.export.export(strict=False) -> to_edge_transform_and_lower(partitioner=[WebGPUPartitioner()]) -> to_executorch()",
+    "partitioner": "executorch.backends.webgpu.partitioner.WebGPUPartitioner() (default compile options; wraps VulkanPartitioner; delegate id VulkanBackend)",
+    "model_code": "recipes/_whisper.py wrappers around the transformers modules (weights shared, forward re-expressed): MelProgram, EncoderProgram, CrossKVProgram, DecoderSplitProgram, DecodeStreamProgram, LMHeadProgram",
+    "quantization": {
+      "decoder_side_linears": {
+        "programs": [
+          "cross_kv",
+          "decoder_split",
+          "decode_stream"
+        ],
+        "config": "none (fp32)",
+        "lowered_to": "aten.linear (2-D fp32)"
+      },
+      "lmhead": {
+        "config": "PT2E with executorch.backends.vulkan.quantizer.VulkanQuantizer: weights int8 per-output-channel symmetric (PerChannelMinMaxObserver, the quantizer's own weight spec), input activation int8 per-tensor affine STATIC (HistogramObserver) calibrated on lmhead inputs; lowers to quantized_decomposed.quantize_per_tensor + et_vk.linear_q8ta_q8csw",
+        "lowered_to": "quantized_decomposed.quantize_per_tensor + et_vk.linear_q8ta_q8csw",
+        "calibration_clips": [
+          "1272-128104-0004",
+          "1272-128104-0009",
+          "1272-128104-0011"
+        ],
+        "calibration_vectors": 157,
+        "input_scale": 1.7133680582046509,
+        "input_zero_point": 84
+      },
+      "fp32_programs": [
+        "mel",
+        "encoder"
+      ],
+      "embedding_table": "int8 rowwise (whisper_embed.i8.bin + whisper_embed.scale.f32.bin)"
+    },
+    "encoder_attention": "eager",
+    "decoder_attention": "et_vk.sdpa (decoder_split self-attention with a [1,8,64,64] additive causal mask of 0 / -1e30; cross-attention in decoder_split and decode_stream); decode_stream self-attention = llama.update_cache + llama.custom_sdpa, fused by the Vulkan partitioner into sdpa_with_kv_cache + et_vk.select_as_symint",
+    "lmhead_rows": "51872: vocab 51865 padded with zero weights and bias -1000000000.0 (executorch 1.5.1's q4gsw lowering fails for N % 4 != 0; kept for fp32 too so the contract is identical)",
+    "constants": {
+      "max_decoder_rows": 64,
+      "self_attention_cache": [
+        1,
+        448,
+        8,
+        64
+      ],
+      "frames": [
+        3000,
+        400
+      ],
+      "hop": 160,
+      "prefix_en": [
+        50258,
+        50259,
+        50359,
+        50363
+      ]
+    },
+    "host_contract": {
+      "frames": "whisper.js buildFrames: zero-pad pcm to 480000 samples, reflect-pad 200 each side, 3000 x 400 windows at hop 160",
+      "log_mel": "between mel and encoder: x = log10(max(p, 1e-10)); x = max(x, max(x) - 8); x = (x + 4) / 4; transpose [1,3000,80] -> [1,80,3000]",
+      "embeddings": "i8[id] * scale[id]; decoder_split: rows 0..p = token embeddings (no positions), zero rows after; decode_stream: token embedding + pos_embed[p]",
+      "argmax": "over logits[..., :51865] (rows 51865..51871 are -1000000000.0)",
+      "cross_kv": "computed once per 30 s window, then passed as 12 inputs to every decoder call"
+    },
+    "io": {
+      "mel": {
+        "forward": {
+          "inputs": [
+            {
+              "shape": [
+                1,
+                3000,
+                400
+              ],
+              "dtype": "float"
+            }
+          ],
+          "outputs": [
+            {
+              "shape": [
+                1,
+                3000,
+                80
+              ],
+              "dtype": "float"
+            }
+          ]
+        }
+      },
+      "encoder": {
+        "forward": {
+          "inputs": [
+            {
+              "shape": [
+                1,
+                80,
+                3000
+              ],
+              "dtype": "float"
+            }
+          ],
+          "outputs": [
+            {
+              "shape": [
+                1,
+                1500,
+                512
+              ],
+              "dtype": "float"
+            }
+          ]
+        }
+      },
+      "cross_kv": {
+        "forward": {
+          "inputs": [
+            {
+              "shape": [
+                1,
+                1500,
+                512
+              ],
+              "dtype": "float"
+            }
+          ],
+          "outputs": [
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            }
+          ]
+        }
+      },
+      "decoder_split": {
+        "forward": {
+          "inputs": [
+            {
+              "shape": [
+                1,
+                64,
+                512
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            }
+          ],
+          "outputs": [
+            {
+              "shape": [
+                1,
+                64,
+                512
+              ],
+              "dtype": "float"
+            }
+          ]
+        }
+      },
+      "decode_stream": {
+        "forward": {
+          "inputs": [
+            {
+              "shape": [
+                1,
+                1,
+                512
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1
+              ],
+              "dtype": "long"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            },
+            {
+              "shape": [
+                1,
+                8,
+                1500,
+                64
+              ],
+              "dtype": "float"
+            }
+          ],
+          "outputs": [
+            {
+              "shape": [
+                1,
+                1,
+                512
+              ],
+              "dtype": "float"
+            }
+          ]
+        }
+      },
+      "lmhead": {
+        "forward": {
+          "inputs": [
+            {
+              "shape": [
+                1,
+                1,
+                512
+              ],
+              "dtype": "float"
+            }
+          ],
+          "outputs": [
+            {
+              "shape": [
+                1,
+                1,
+                51872
+              ],
+              "dtype": "float"
+            }
+          ]
+        }
+      }
+    }
+  },
+  "files": {
+    "whisper_mel.pte": {
+      "bytes": 710976,
+      "sha256": "7cae31829487958454c5a14aecfed0845f6320dd480c24883861fa39b07de497"
+    },
+    "whisper_encoder.pte": {
+      "bytes": 82420996,
+      "sha256": "841e7702ba8fa73594f0b4e1400230d6b686af958628ead6b22919e9a3e27c69"
+    },
+    "whisper_cross_kv.pte": {
+      "bytes": 12610560,
+      "sha256": "6e8078924168c21a863ff662e9ccba55ed86bb3826dabd28fea77010e3151012"
+    },
+    "whisper_decoder_split.pte": {
+      "bytes": 88619264,
+      "sha256": "ade1aedc9e5795ac8c224347b88f1b826f5598e68d1df0961695fd843fa0e9b5"
+    },
+    "whisper_decode_stream.pte": {
+      "bytes": 89270912,
+      "sha256": "bc2f33ad7aa164059e819247365e2e0a75a3f1a2973024e4fdc67a254d7faa8d"
+    },
+    "whisper_lmhead.pte": {
+      "bytes": 27184000,
+      "sha256": "68577fa240d29923058fd72b94db583f3ff171302ad12834c2b610e04c559f8e"
+    },
+    "whisper_embed.i8.bin": {
+      "bytes": 26554880,
+      "sha256": "bc7f8d8336ad935eb8b6374036478d92d679eae156a1d4188d5cc016b5f2dda2"
+    },
+    "whisper_embed.scale.f32.bin": {
+      "bytes": 207460,
+      "sha256": "1f58851911611b9686851c586365df2fcaaa0727957c05bd163d7c3ccc231f4d"
+    },
+    "whisper_pos_embed.f32.bin": {
+      "bytes": 917504,
+      "sha256": "88fa1cdbf2b06f86b0ecb7be0fccfc39e906502986572b8cf5319c250e857169"
+    },
+    "vocab.json": {
+      "bytes": 835550,
+      "sha256": "8f680bba319e01a653d2e8a5dbc17a9157179e0576e6ce74ce0c06356c6e24f9"
+    }
+  },
+  "graph": {
+    "mel": {
+      "non_delegated_kernels": {},
+      "delegates": [
+        {
+          "id": "VulkanBackend",
+          "ops": {
+            "aten.squeeze_copy.dims": 1,
+            "aten.linear.default": 3,
+            "aten.mul.Tensor": 2,
+            "aten.add.Tensor": 1,
+            "aten.view_copy.default": 1
+          },
+          "inputs": 1,
+          "outputs": 1
+        }
+      ]
+    },
+    "encoder": {
+      "non_delegated_kernels": {},
+      "delegates": [
+        {
+          "id": "VulkanBackend",
+          "ops": {
+            "et_vk.prepack.default": 7,
+            "aten.convolution.default": 2,
+            "aten.gelu.default": 8,
+            "aten.clone.default": 1,
+            "aten.permute_copy.default": 31,
+            "aten.squeeze_copy.dims": 25,
+            "aten.add.Tensor": 13,
+            "aten.native_layer_norm.default": 13,
+            "aten.linear.default": 36,
+            "aten.view_copy.default": 37,
+            "aten.mul.Tensor": 6,
+            "aten.bmm.default": 12,
+            "aten._softmax.default": 6
+          },
+          "inputs": 1,
+          "outputs": 1
+        }
+      ]
+    },
+    "cross_kv": {
+      "non_delegated_kernels": {},
+      "delegates": [
+        {
+          "id": "VulkanBackend",
+          "ops": {
+            "aten.squeeze_copy.dims": 12,
+            "aten.linear.default": 12,
+            "aten.view_copy.default": 12,
+            "aten.permute_copy.default": 12
+          },
+          "inputs": 1,
+          "outputs": 12
+        }
+      ]
+    },
+    "decoder_split": {
+      "non_delegated_kernels": {},
+      "delegates": [
+        {
+          "id": "VulkanBackend",
+          "ops": {
+            "et_vk.prepack.default": 2,
+            "aten.add.Tensor": 19,
+            "aten.native_layer_norm.default": 19,
+            "aten.squeeze_copy.dims": 30,
+            "aten.linear.default": 48,
+            "aten.view_copy.default": 60,
+            "aten.permute_copy.default": 36,
+            "et_vk.sdpa.default": 12,
+            "aten.gelu.default": 6
+          },
+          "inputs": 13,
+          "outputs": 1
+        }
+      ]
+    },
+    "decode_stream": {
+      "non_delegated_kernels": {},
+      "delegates": [
+        {
+          "id": "VulkanBackend",
+          "ops": {
+            "et_vk.select_as_symint.default": 1,
+            "aten.native_layer_norm.default": 19,
+            "aten.squeeze_copy.dims": 30,
+            "aten.linear.default": 48,
+            "aten.view_copy.default": 42,
+            "sdpa_with_kv_cache.default": 6,
+            "aten.unsqueeze_copy.default": 18,
+            "aten.add.Tensor": 18,
+            "aten.permute_copy.default": 12,
+            "et_vk.sdpa.default": 6,
+            "aten.gelu.default": 6
+          },
+          "inputs": 14,
+          "outputs": 1
+        }
+      ]
+    },
+    "lmhead": {
+      "non_delegated_kernels": {},
+      "delegates": [
+        {
+          "id": "VulkanBackend",
+          "ops": {
+            "quantized_decomposed.quantize_per_tensor.default": 1,
+            "aten.clone.default": 1,
+            "et_vk.linear_q8ta_q8csw.default": 1
+          },
+          "inputs": 1,
+          "outputs": 1
+        }
+      ]
+    }
+  },
+  "webgpu_runtime_checks": {
+    "op_list": "checked against --runtime-ops",
+    "mel": {
+      "problems": [],
+      "ok": true,
+      "notes": {
+        "value_kinds": [
+          "FLOAT32",
+          "Int",
+          "IntList",
+          "Null"
+        ],
+        "aten.linear input ranks": [
+          "2"
+        ]
+      }
+    },
+    "encoder": {
+      "problems": [],
+      "ok": true,
+      "notes": {
+        "value_kinds": [
+          "Bool",
+          "Double",
+          "FLOAT32",
+          "Int",
+          "IntList",
+          "Null",
+          "String",
+          "ValueList"
+        ],
+        "aten.convolution input/weight": [
+          "((1, 512, 3000), (512, 512, 3))",
+          "((1, 80, 3000), (512, 80, 3))"
+        ],
+        "aten.linear input ranks": [
+          "2"
+        ]
+      }
+    },
+    "cross_kv": {
+      "problems": [],
+      "ok": true,
+      "notes": {
+        "value_kinds": [
+          "FLOAT32",
+          "IntList",
+          "Null"
+        ],
+        "aten.linear input ranks": [
+          "2"
+        ]
+      }
+    },
+    "decoder_split": {
+      "problems": [],
+      "ok": true,
+      "notes": {
+        "value_kinds": [
+          "Double",
+          "FLOAT32",
+          "Int",
+          "IntList",
+          "Null",
+          "String",
+          "ValueList"
+        ],
+        "aten.linear input ranks": [
+          "2"
+        ],
+        "et_vk.sdpa q/k/mask": [
+          "((1, 8, 64, 64), (1, 8, 1500, 64), None)",
+          "((1, 8, 64, 64), (1, 8, 64, 64), (1, 8, 64, 64))"
+        ]
+      }
+    },
+    "decode_stream": {
+      "problems": [],
+      "ok": true,
+      "notes": {
+        "value_kinds": [
+          "Bool",
+          "Double",
+          "FLOAT32",
+          "INT32",
+          "Int",
+          "IntList",
+          "Null",
+          "String",
+          "SymInt",
+          "ValueList"
+        ],
+        "aten.linear input ranks": [
+          "2"
+        ],
+        "sdpa_with_kv_cache q/k_cache": [
+          "((1, 1, 8, 64), (1, 448, 8, 64), 'SymInt')"
+        ],
+        "et_vk.sdpa q/k/mask": [
+          "((1, 8, 1, 64), (1, 8, 1500, 64), None)"
+        ]
+      }
+    },
+    "lmhead": {
+      "problems": [],
+      "ok": true,
+      "notes": {
+        "value_kinds": [
+          "Double",
+          "FLOAT32",
+          "INT32",
+          "INT8",
+          "Int",
+          "Null"
+        ]
+      }
+    }
+  },
+  "command": "python recipes/whisper-base.py --out out/whisper-base/fp32dec-lmq8 --precision fp32dec-lmq8"
+}

export/requirements.txt

@@ -0,0 +1,18 @@
+# Environment the re-exports in REEXPORT.md were produced with (Python 3.12, Linux x86_64, CPU only).
+#   python -m venv venv
+#   venv/bin/pip install -r recipes/requirements.txt --extra-index-url https://download.pytorch.org/whl/cpu
+# executorch 1.5.1 = pytorch/executorch git 3b60683923245cf472b7323426920e15623ba361; its wheel ships
+# backends/webgpu (WebGPUPartitioner) and examples/models/llama (export_llm).
+executorch==1.5.1
+torch==2.14.1+cpu
+torchvision==0.29.1+cpu
+torchao==0.18.0+cpu
+transformers==5.19.0
+huggingface_hub==2.2.0
+safetensors==0.8.0
+tokenizers==0.23.3
+numpy==2.5.4
+pillow==12.3.0
+# whisper-base: decode the LibriSpeech clips used for the output-layer calibration and validation
+soundfile==0.14.0
+pyarrow==26.0.0

export/whisper-base.py

@@ -0,0 +1,784 @@
+#!/usr/bin/env python3
+"""Whisper base (openai/whisper-base) -> six ExecuTorch WebGPU programs + host tables, public ExecuTorch.
+
+Same split and program I/O contract as the playground's previous export (per-program contract in
+recipes/_whisper.py):
+
+  whisper_mel.pte            frames[1,3000,400] -> power mel[1,3000,80]                        fp32
+  whisper_encoder.pte        log-mel[1,80,3000] -> encoder hidden[1,1500,512]                  fp32
+  whisper_cross_kv.pte       encoder hidden -> 12 x [1,8,1500,64] (k0,v0,...,k5,v5)
+  whisper_decoder_split.pte  (tok embeds[1,64,512], 12 cross K/V) -> hidden[1,64,512]
+  whisper_decode_stream.pte  (embed+pos[1,1,512], pos[1] i64, 12 cross K/V) -> hidden[1,1,512]
+  whisper_lmhead.pte         hidden[1,1,512] -> logits[1,1,51872] (rows >= 51865 are -1e9)
+  whisper_pos_embed.f32.bin, vocab.json, and the token-embedding table:
+
+  --precision q4   (default; the previous export's numerics) cross_kv / decoder_split / decode_stream
+                   / lmhead linears int4 groupwise (et_vk.linear_q4gsw, group 64; quantized weights
+                   bit-identical to the previous files) + whisper_embed.i8.bin / .scale.f32.bin.
+  --precision fp32 every program fp32 + whisper_embed.f32.bin. Larger, but its greedy transcripts
+                   are token-identical to transformers (int4 weights are not; see validation.json).
+  --precision hybrid-lmfp32  as q4, but lmhead fp32 (aten.linear).
+  --precision hybrid-lmq8    as q4, but lmhead int8 x int8 (static per-tensor input scale calibrated on
+                   the 3 LibriSpeech-dummy clips longer than 15 s; et_vk.linear_q8ta_q8csw).
+  --precision fp32dec-lmq8   fp32 cross_kv / decoder_split / decode_stream, the int8 x int8 lmhead above
+                   (calibrated on the fp32 decoder's hidden states) and the int8 embedding table.
+
+Every program is lowered with executorch.backends.webgpu.partitioner.WebGPUPartitioner() into one
+VulkanBackend delegate with no CPU kernels. The host does: framing, the log-mel normalization between
+mel and encoder (log10 / max-8 / (x+4)/4 / transpose; the public runtime has no log op), token
+embedding lookup (+ positional row for decode_stream), and argmax.
+
+  python recipes/whisper-base.py --out out/whisper-base/q4                     # export + validation
+  python recipes/whisper-base.py --out out/whisper-base/fp32 --precision fp32
+  python recipes/whisper-base.py --out /tmp/w --no-validate                    # export only
+
+Validation (CPU only; the WebGPU kernels cannot run here): eager vs torch.export program vs portable
+.pte (ExecuTorch pybindings) for every program, and greedy transcripts of LibriSpeech clips
+(hf-internal-testing/librispeech_asr_dummy) through the full host + program pipeline, compared token
+by token with transformers WhisperForConditionalGeneration.
+"""
+
+import argparse
+import copy
+import json
+import shutil
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import _common  # noqa: E402
+import _whisper as W  # noqa: E402
+
+UPSTREAM = {
+    "repo": "openai/whisper-base",
+    "revision": "e37978b90ca9030d5170a5c07aadb050351a65bb",
+    "files": {
+        "model.safetensors": "07cadb9f25677c8d50df603e66a98fbd842cce45047139baeb16e6219a1e807b",
+        "config.json": "a153c53883a6799b6f056b4a8d1a515c9926d03994682ba88a7616618d7da0c1",
+        "generation_config.json": "444b3f636d2fff89dd9ecf549e2a085b61f7ff0fa0246d4628bac6a3b8cc9ba4",
+        "preprocessor_config.json": "9b5cd03a36fbb8a627c64d98a5b5b126ead95a77720723944487311f0110b666",
+        "vocab.json": "8f680bba319e01a653d2e8a5dbc17a9157179e0576e6ce74ce0c06356c6e24f9",
+        "tokenizer.json": "27fc476bfe7f17299480be2273fc0608e4d5a99aba2ab5dec5374b4482d1a566",
+        "tokenizer_config.json": "2a4c4281cf9f51ac6ccc406fdc711a087afe6530f671fa7b80953edc498275ce",
+        "merges.txt": "2df2990a395e35e8dfbc7511e08c12d56018d8d04691e0133e5d63b21e154dc6",
+        "normalizer.json": "bf1c507dc8724ca9cf9903640dacfb69dae2f00edee4f21ceba106a7392f26dd",
+        "added_tokens.json": "9715fd2243b6f06a5858b5e32950d2853f73dd5bc201aafcf76f5082a2d8acd1",
+        "special_tokens_map.json": "e67ae3a0aaa99abcd9f187138e12db1f65c16a14761c50ef10eef2c174a7a691",
+    },
+}
+SAMPLE = {
+    "repo": "hf-internal-testing/librispeech_asr_dummy",
+    "repo_type": "dataset",
+    "revision": "5be91486e11a2d616f4ec5db8d3fd248585ac07a",
+    "file": "clean/validation-00000-of-00001.parquet",
+    "sha256": "4e69a06fa5edc90921e5e7e39a7084881f8b3ed9c805c574f4f39c6fde27c603",
+}
+NAMES = ["mel", "encoder", "cross_kv", "decoder_split", "decode_stream", "lmhead"]
+DECODER_SIDE = ["cross_kv", "decoder_split", "decode_stream", "lmhead"]
+
+
+def fetch_upstream():
+    snap, digests = None, {}
+    for f, sha in UPSTREAM["files"].items():
+        p, d = _common.hf_file(UPSTREAM["repo"], f, UPSTREAM["revision"], sha)
+        digests[f] = d
+        snap = p.parent
+    return snap, digests
+
+
+def fetch_sample():
+    from huggingface_hub import hf_hub_download
+
+    p = hf_hub_download(
+        SAMPLE["repo"],
+        SAMPLE["file"],
+        repo_type=SAMPLE["repo_type"],
+        revision=SAMPLE["revision"],
+    )
+    d = _common.sha256_file(p)
+    if d != SAMPLE["sha256"]:
+        sys.exit(f"{SAMPLE['repo']}:{SAMPLE['file']} sha256 {d} != {SAMPLE['sha256']}")
+    return p
+
+
+def example_inputs(name):
+    g = torch.Generator().manual_seed(0)
+    ckv = tuple(torch.randn(1, 8, W.ENC_LEN, 64, generator=g) for _ in range(12))
+    return {
+        "mel": (torch.randn(1, W.FRAMES, W.N_FFT, generator=g),),
+        "encoder": (torch.randn(1, W.N_MELS, W.FRAMES, generator=g),),
+        "cross_kv": (torch.randn(1, W.ENC_LEN, W.D_MODEL, generator=g),),
+        "decoder_split": (torch.randn(1, W.MAX_DEC, W.D_MODEL, generator=g),) + ckv,
+        "decode_stream": (torch.randn(1, 1, W.D_MODEL, generator=g), torch.tensor([0]))
+        + ckv,
+        "lmhead": (torch.randn(1, 1, W.D_MODEL, generator=g),),
+    }[name]
+
+
+PRECISIONS = {
+    # name: (decoder-side linears, lmhead, host embedding table)
+    "q4": ("int4", "int4", "int8"),
+    "hybrid-lmfp32": ("int4", "fp32", "int8"),
+    "hybrid-lmq8": ("int4", "int8 static-act", "int8"),
+    "fp32dec-lmq8": ("fp32", "int8 static-act", "int8"),
+    "fp32": ("fp32", "fp32", "fp32"),
+}
+
+
+def calibration_hidden(model, fe, dec, tables, max_sec):
+    """lmhead inputs for the q8 head's static activation scale: the variant's decoder's hidden states
+    for every decoded position of the LibriSpeech dummy clips LONGER than max_sec (3 clips, first
+    30 s window), which are disjoint from the evaluation clips. Tokens are chosen with the fp32
+    head (greedy, playground prefix)."""
+    clips = W.load_librispeech_dummy(fetch_sample(), max_sec, 100, longer=True)
+    stream = W.DecodeStreamProgram(dec, "torch")
+    ckvp = W.CrossKVProgram(dec)
+    mel, enc = W.MelProgram(fe), W.EncoderProgram(model, "eager")
+    lm32 = W.LMHeadProgram(model, W.VOCAB_PADDED)
+    hs = []
+    with torch.no_grad():
+        for c in clips:
+            lmel = W.host_log_mel(mel(torch.from_numpy(W.build_frames(c["pcm"]))[None]).numpy())
+            ckv = ckvp(enc(torch.from_numpy(lmel)))
+            stream.reset()
+            ids = list(W.PREFIX_EN)
+            for p in range(W.MAX_DEC):
+                h = stream(torch.from_numpy(tables.embed(ids[p], p)[None, None]), torch.tensor([p]), *ckv)
+                if p < len(W.PREFIX_EN) - 1:
+                    continue
+                hs.append(h)
+                nxt = int(lm32(h).reshape(-1)[: W.VOCAB].argmax())
+                if nxt == W.TOK["eot"] or len(ids) + 1 >= W.MAX_DEC:
+                    break
+                ids.append(nxt)
+    return torch.cat(hs, 0), [c["id"] for c in clips]
+
+
+def build_programs(model, fe, precision, encoder_attn, tables, max_sec):
+    """name -> (module lowered for WebGPU, module for the CPU portable .pte, fp32 reference or None).
+
+    The portable module computes the same function with ops the portable runtime has: attention as
+    matmul+softmax instead of et_vk.sdpa, the fp32 dequantization of the same int4 weights, and for
+    the q8 head an explicit per-tensor fake-quant + dequantized int8 weights."""
+    dec_kind, lm_kind, _ = PRECISIONS[precision]
+    fdec = model.model.decoder
+    lm32 = W.LMHeadProgram(model, W.VOCAB_PADDED)
+    info = {}
+    if dec_kind == "int4":
+        wdec = W.quantize_q4(copy.deepcopy(fdec))
+        pdec = W.dequantized_copy(wdec)
+        dref = lambda m: m  # noqa: E731
+    else:
+        wdec = pdec = fdec
+        dref = lambda m: None  # noqa: E731
+    if lm_kind == "int4":
+        wlm = W.quantize_q4(copy.deepcopy(lm32))
+        plm, lref = W.dequantized_copy(wlm), lm32
+    elif lm_kind == "fp32":
+        wlm = plm = lm32
+        lref = None
+    else:
+        calib, calib_ids = calibration_hidden(model, fe, wdec, tables, max_sec)
+        wlm, qp, wdq = W.q8_lmhead(lm32, calib)
+        plm, lref = W.FakeQ8LMHead(lm32, qp, wdq), lm32
+        info = {
+            "calibration_clips": calib_ids,
+            "calibration_vectors": int(calib.shape[0]),
+            "input_scale": qp[0],
+            "input_zero_point": qp[1],
+        }
+    progs = {
+        "mel": (W.MelProgram(fe), W.MelProgram(fe), None),
+        "encoder": (W.EncoderProgram(model, encoder_attn), W.EncoderProgram(model, "eager"), None),
+        "cross_kv": (W.CrossKVProgram(wdec), W.CrossKVProgram(pdec), dref(W.CrossKVProgram(fdec))),
+        "decoder_split": (
+            W.DecoderSplitProgram(wdec, "et_vk"),
+            W.DecoderSplitProgram(pdec, "torch"),
+            dref(W.DecoderSplitProgram(fdec, "torch")),
+        ),
+        "decode_stream": (
+            W.DecodeStreamProgram(wdec, "et_vk"),
+            W.DecodeStreamProgram(pdec, "torch"),
+            dref(W.DecodeStreamProgram(fdec, "torch")),
+        ),
+        "lmhead": (wlm, plm, lref),
+    }
+    return progs, info
+
+
+def export_one(module, inputs):
+    if isinstance(module, W.DecodeStreamProgram):
+        module.reset()  # the serialized K/V cache must start as zeros
+    with torch.no_grad():
+        if not isinstance(module, torch.fx.GraphModule):  # pt2e-converted modules have no eval()
+            module = module.eval()
+        return torch.export.export(module, inputs, strict=False)
+
+
+# ---------------------------------------------------------------------------------------------
+# Runners: run(name, [arrays]) -> [np arrays]; reset() clears decode_stream's K/V cache.
+# ---------------------------------------------------------------------------------------------
+
+
+class ModuleRunner:
+    def __init__(self, modules):
+        self.m = modules
+
+    def reset(self):
+        for m in self.m.values():
+            if isinstance(m, W.DecodeStreamProgram):
+                m.reset()
+            elif hasattr(m, "named_buffers"):
+                for n, b in m.named_buffers():
+                    if "cache" in n:
+                        b.zero_()
+
+    def __call__(self, name, inputs):
+        with torch.no_grad():
+            out = self.m[name](
+                *[torch.from_numpy(np.ascontiguousarray(x)) for x in inputs]
+            )
+        out = out if isinstance(out, (tuple, list)) else (out,)
+        return [o.detach().numpy() for o in out]
+
+
+class PteRunner:
+    def __init__(self, ptes):
+        from executorch.extension.pybindings.portable_lib import (
+            _load_for_executorch_from_buffer,
+        )
+
+        self._load = _load_for_executorch_from_buffer
+        self.ptes = ptes
+        self.m = {k: self._load(v) for k, v in ptes.items()}
+
+    def reset(self):
+        if "decode_stream" in self.ptes:  # fresh method = zeroed mutable K/V buffers
+            self.m["decode_stream"] = self._load(self.ptes["decode_stream"])
+
+    def __call__(self, name, inputs):
+        out = self.m[name].forward(
+            [torch.from_numpy(np.ascontiguousarray(x)) for x in inputs]
+        )
+        return [
+            o.detach().numpy() if isinstance(o, torch.Tensor) else np.asarray(o)
+            for o in out
+        ]
+
+
+def encode_window(run, pcm):
+    power = run("mel", [W.build_frames(pcm)[None]])[0]
+    log_mel = W.host_log_mel(power)
+    enc = run("encoder", [log_mel])[0]
+    return log_mel, enc, run("cross_kv", [enc])
+
+
+def greedy_stream(run, ckv, tables, max_dec=W.MAX_DEC):
+    """whisper.js #window() with the streaming decoder: one token per call, argmax over 51865."""
+    run.reset()
+    ids = list(W.PREFIX_EN)
+    for p in range(max_dec):
+        e = tables.embed(ids[p], p)[None, None]
+        h = run("decode_stream", [e, np.array([p], dtype=np.int64), *ckv])[0]
+        if p < len(W.PREFIX_EN) - 1:
+            continue
+        nxt = int(np.argmax(run("lmhead", [h])[0].reshape(-1)[: W.VOCAB]))
+        if nxt == W.TOK["eot"]:
+            break
+        ids.append(nxt)
+        if len(ids) >= max_dec:
+            break
+    return ids[len(W.PREFIX_EN) :]
+
+
+def greedy_split(run, ckv, tables, max_dec=W.MAX_DEC):
+    """whisper.js #window() with the full-recompute decoder_split (no positions on the host)."""
+    ids = list(W.PREFIX_EN)
+    for p in range(len(W.PREFIX_EN) - 1, max_dec):
+        te = np.zeros((1, W.MAX_DEC, W.D_MODEL), dtype=np.float32)
+        te[0, : p + 1] = tables.embed(np.array(ids[: p + 1]))
+        h = run("decoder_split", [te, *ckv])[0]
+        nxt = int(np.argmax(run("lmhead", [h[:, p : p + 1]])[0].reshape(-1)[: W.VOCAB]))
+        if nxt == W.TOK["eot"]:
+            break
+        ids.append(nxt)
+        if len(ids) >= max_dec:
+            break
+    return ids[len(W.PREFIX_EN) :]
+
+
+def hf_generate(model, feats, max_new):
+    with torch.no_grad():
+        seq = model.generate(
+            feats,
+            language="en",
+            task="transcribe",
+            return_timestamps=False,
+            do_sample=False,
+            num_beams=1,
+            max_new_tokens=max_new,
+        )[0].tolist()
+    # transformers 5 returns only the generated tokens; older versions also return the prompt.
+    out = seq[len(W.PREFIX_EN) :] if seq[: len(W.PREFIX_EN)] == W.PREFIX_EN else seq
+    return out[: out.index(W.TOK["eot"])] if W.TOK["eot"] in out else out
+
+
+def hf_greedy(model, feats, max_dec=W.MAX_DEC):
+    """Pure argmax with the forced prefix and no logit processors (the playground's rule)."""
+    with torch.no_grad():
+        enc = model.model.encoder(feats)
+        ids = list(W.PREFIX_EN)
+        while len(ids) < max_dec:
+            logits = model(
+                encoder_outputs=enc, decoder_input_ids=torch.tensor([ids])
+            ).logits
+            nxt = int(logits[0, -1].argmax())
+            if nxt == W.TOK["eot"]:
+                break
+            ids.append(nxt)
+    return ids[len(W.PREFIX_EN) :]
+
+
+def first_diff(a, b):
+    for i, (x, y) in enumerate(zip(a, b)):
+        if x != y:
+            return i
+    return None if len(a) == len(b) else min(len(a), len(b))
+
+
+def summarize(rs):
+    if len(rs) == 1:
+        return rs[0]
+    return {
+        "outputs": len(rs),
+        "worst_max_abs": max(d["max_abs"] for d in rs),
+        "worst_max_rel_to_absmax": max(d["max_rel_to_absmax"] for d in rs),
+        "min_cosine": min(d["cosine"] for d in rs),
+    }
+
+
+def cmp(a, b):
+    return summarize([W.isclose_report(x, y) for x, y in zip(a, b)])
+
+
+# ---------------------------------------------------------------------------------------------
+
+
+def validate(args, out, model, fe, tok, progs, eps, ptes, tables):
+    t0 = time.time()
+    clips = W.load_librispeech_dummy(fetch_sample(), args.max_sec, args.clips)
+    report = {
+        "precision": args.precision,
+        "cpu_runtime": "executorch pybindings (portable_lib) from the pip wheel, with "
+        "executorch.extension.llm.custom_ops loaded (llama::update_cache / custom_sdpa kernels)",
+        "webgpu_pte_on_cpu": "not runnable: the pip wheel's pybindings have no WebGPU/Vulkan backend, "
+        "so the lowered GPU kernels themselves are not exercised here",
+        "portable_pte_note": "portable .pte = the same function exported without a delegate, with "
+        "attention as matmul+softmax (et_vk.sdpa has no portable kernel) and, for q4, the fp32 "
+        "dequantization of the same int4 weights (torchao ops have no portable kernels). It checks graph "
+        "structure, the host contract and the quantized numerics on the ExecuTorch runtime",
+        "sample": {
+            **SAMPLE,
+            "clips_used": [c["id"] for c in clips],
+            "max_sec": args.max_sec,
+        },
+        "programs": {},
+    }
+    pcm0 = clips[0]["pcm"]
+    eager = ModuleRunner({k: v[0] for k, v in progs.items()})
+    exported = ModuleRunner({k: e.module() for k, e in eps.items()})
+    pte = PteRunner(ptes)
+    log_mel0, enc0, ckv0 = encode_window(eager, pcm0)
+    dec_in = np.zeros((1, W.MAX_DEC, W.D_MODEL), np.float32)
+    dec_in[0, :4] = tables.embed(np.array(W.PREFIX_EN))
+    speech = {
+        "mel": [W.build_frames(pcm0)[None]],
+        "encoder": [log_mel0],
+        "cross_kv": [enc0],
+        "decoder_split": [dec_in, *ckv0],
+    }
+    for name in NAMES:
+        mod, _, ref32 = progs[name]
+        res = {}
+        if name != "decode_stream":
+            cases = {"random": [x.numpy() for x in example_inputs(name)]}
+            if name in speech:
+                cases["speech"] = speech[name]
+            if name == "lmhead":
+                cases["speech"] = [
+                    eager("decoder_split", speech["decoder_split"])[0][:, 3:4]
+                ]
+            for label, inp in cases.items():
+                e = eager(name, inp)
+                r = {
+                    "exported_vs_eager": cmp(exported(name, inp), e),
+                    "portable_pte_vs_eager": cmp(pte(name, inp), e),
+                }
+                if ref32 is not None:
+                    r["quantized_eager_vs_fp32_eager"] = cmp(
+                        e, ModuleRunner({name: ref32})(name, inp)
+                    )
+                res[label] = r
+        else:
+            # 12 steps from a fresh cache: the 4 prefix tokens, then a fixed continuation.
+            seq = W.PREFIX_EN + [440, 1029, 291, 4532, 13, 50, 2034, 293]
+            runners = {
+                "eager": ModuleRunner({name: mod}),
+                "exported": exported,
+                "portable_pte": PteRunner({name: ptes[name]}),
+            }
+            if ref32 is not None:
+                runners["fp32_eager"] = ModuleRunner({name: ref32})
+            outs = {}
+            for k, rr in runners.items():
+                rr.reset()
+                hs = [
+                    rr(
+                        name,
+                        [
+                            tables.embed(t_, p_)[None, None],
+                            np.array([p_], dtype=np.int64),
+                            *ckv0,
+                        ],
+                    )[0]
+                    for p_, t_ in enumerate(seq)
+                ]
+                outs[k] = np.concatenate(hs, 1)
+            r = {
+                "exported_vs_eager": W.isclose_report(outs["exported"], outs["eager"]),
+                "portable_pte_vs_eager": W.isclose_report(
+                    outs["portable_pte"], outs["eager"]
+                ),
+            }
+            if ref32 is not None:
+                r["quantized_eager_vs_fp32_eager"] = W.isclose_report(
+                    outs["eager"], outs["fp32_eager"]
+                )
+            te = np.zeros((1, W.MAX_DEC, W.D_MODEL), np.float32)
+            te[0, : len(seq)] = tables.embed(np.array(seq))
+            hsplit = eager("decoder_split", [te, *ckv0])[0]
+            r["stream_vs_decoder_split_eager"] = W.isclose_report(
+                outs["eager"], hsplit[:, : len(seq)]
+            )
+            res["speech_12_steps"] = r
+        report["programs"][name] = res
+        print(f"[validate] {name}: {json.dumps(res)[:300]}", flush=True)
+
+    e32 = model.model.decoder.embed_tokens.weight.detach().numpy()
+    report["host_tables"] = {
+        "kind": tables.kind,
+        "embed_vs_checkpoint": W.isclose_report(tables.embed(np.arange(W.VOCAB)), e32),
+        "pos_embed_equals_checkpoint": bool(
+            np.array_equal(
+                tables.pos, model.model.decoder.embed_positions.weight.detach().numpy()
+            )
+        ),
+    }
+
+    # End-to-end greedy transcripts.
+    keys = ["exported_stream", "exported_split"]
+    e2e = []
+    for ci, c in enumerate(clips):
+        t1 = time.time()
+        pcm = c["pcm"]
+        feats = fe(pcm, sampling_rate=W.SAMPLE_RATE, return_tensors="pt").input_features
+        hf_gen = hf_generate(model, feats, W.MAX_DEC - len(W.PREFIX_EN))
+        hf_arg = hf_greedy(model, feats)
+        log_mel_x, _, ckv_x = encode_window(exported, pcm)
+        row = {
+            "id": c["id"],
+            "seconds": W.seconds(pcm),
+            "reference_text": c["text"],
+            "log_mel_vs_hf_features": W.isclose_report(log_mel_x, feats.numpy()),
+            "hf_generate": hf_gen,
+            "hf_greedy_argmax": hf_arg,
+            "exported_stream": greedy_stream(exported, ckv_x, tables),
+            "exported_split": greedy_split(exported, ckv_x, tables),
+        }
+        if ci < args.portable_clips:
+            _, _, ckv_p = encode_window(pte, pcm)
+            row["portable_pte_stream"] = greedy_stream(pte, ckv_p, tables)
+            row["portable_pte_split"] = greedy_split(pte, ckv_p, tables)
+        for k in [k for k in row if k.startswith(("exported_", "portable_pte_"))]:
+            row[f"{k}_matches_hf_generate"] = row[k] == hf_gen
+            row[f"{k}_matches_hf_greedy_argmax"] = row[k] == hf_arg
+            if row[k] != hf_gen:
+                row[f"{k}_first_diff_vs_hf_generate"] = first_diff(row[k], hf_gen)
+        row["text_exported_stream"] = tok.decode(
+            row["exported_stream"], skip_special_tokens=True
+        ).strip()
+        row["text_hf_generate"] = tok.decode(hf_gen, skip_special_tokens=True).strip()
+        row["seconds_to_validate"] = round(time.time() - t1, 1)
+        e2e.append(row)
+        flags = {
+            k: row[f"{k}_matches_hf_generate"]
+            for k in row
+            if f"{k}_matches_hf_generate" in row
+        }
+        print(
+            f"[validate] {c['id']} ({row['seconds']} s) {flags} | {row['text_exported_stream']}",
+            flush=True,
+        )
+
+    port = [r for r in e2e if "portable_pte_stream" in r]
+    summary = {
+        "clips": len(e2e),
+        "audio_seconds": round(sum(r["seconds"] for r in e2e), 2),
+        "hf_tokens": sum(len(r["hf_generate"]) for r in e2e),
+        "hf_generate_equals_hf_greedy_argmax": sum(
+            r["hf_generate"] == r["hf_greedy_argmax"] for r in e2e
+        ),
+    }
+    for k in keys:
+        summary[f"{k}_token_exact_vs_hf_generate"] = sum(
+            r[f"{k}_matches_hf_generate"] for r in e2e
+        )
+        summary[f"{k}_token_exact_vs_hf_greedy_argmax"] = sum(
+            r[f"{k}_matches_hf_greedy_argmax"] for r in e2e
+        )
+    summary["portable_pte_clips"] = len(port)
+    for k in ["portable_pte_stream", "portable_pte_split"]:
+        summary[f"{k}_token_exact_vs_hf_generate"] = sum(
+            r[f"{k}_matches_hf_generate"] for r in port
+        )
+        summary[f"{k}_equals_exported_stream"] = sum(
+            r[k] == r["exported_stream"] for r in port
+        )
+    summary["exported_stream_equals_exported_split"] = sum(
+        r["exported_stream"] == r["exported_split"] for r in e2e
+    )
+    wer = {"hf_greedy_argmax": [0, 0], "exported_stream": [0, 0]}
+    for r in e2e:
+        for k in wer:
+            e_, n_ = W.word_errors(tok, tok.decode(r[k], skip_special_tokens=True), r["reference_text"])
+            wer[k][0] += e_
+            wer[k][1] += n_
+    summary["wer_vs_librispeech_text"] = {k: round(v[0] / max(1, v[1]), 4) for k, v in wer.items()}
+    summary["word_errors"] = {k: v for k, v in wer.items()}
+    summary["wer_note"] = "WhisperTokenizer.normalize (English normalizer) on both sides, word-level edit distance"
+    summary["worst_log_mel_vs_hf_features_max_abs"] = max(
+        r["log_mel_vs_hf_features"]["max_abs"] for r in e2e
+    )
+    summary["decode_budget"] = (
+        f"{W.MAX_DEC} positions including the 4-token prefix (playground maxDec)"
+    )
+    summary["pipeline"] = (
+        "build_frames -> mel -> host_log_mel -> encoder -> cross_kv -> [decode_stream | decoder_split] -> "
+        f"lmhead -> argmax over the first {W.VOCAB} logits; token embeddings from the host table "
+        "(+ whisper_pos_embed.f32.bin rows for decode_stream)"
+    )
+    summary["keys"] = {
+        "hf_generate": "WhisperForConditionalGeneration.generate(language='en', task='transcribe', "
+        "return_timestamps=False, greedy, max_new_tokens=60) with the checkpoint's generation_config "
+        "(applies suppress_tokens and begin_suppress_tokens), input_features from WhisperFeatureExtractor",
+        "hf_greedy_argmax": "same model and features, forced prefix <|startoftranscript|><|en|>"
+        "<|transcribe|><|notimestamps|>, plain argmax, no logit processors (the playground's rule)",
+        "exported_*": "the torch.export programs that were lowered for WebGPU (ExportedProgram.module(), "
+        "PyTorch CPU kernels), driven by the host pipeline exactly as whisper.js does",
+        "portable_pte_*": "the portable .pte programs on the ExecuTorch CPU runtime (first "
+        f"{args.portable_clips} clips; slow single-threaded kernels)",
+    }
+    report["end_to_end_summary"] = summary
+    report["end_to_end"] = e2e
+    report["validation_seconds"] = round(time.time() - t0, 1)
+    (out / "validation.json").write_text(json.dumps(report, indent=2) + "\n")
+    print(json.dumps(summary, indent=2))
+
+
+def main():
+    ap = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    ap.add_argument("--out", required=True, help="output directory")
+    ap.add_argument("--precision", choices=list(PRECISIONS), default="q4")
+    ap.add_argument(
+        "--no-validate", action="store_true", help="export only (no CPU validation)"
+    )
+    ap.add_argument(
+        "--clips",
+        type=int,
+        default=70,
+        help="LibriSpeech clips for the transcript check",
+    )
+    ap.add_argument(
+        "--portable-clips",
+        type=int,
+        default=2,
+        help="of those, how many also run as portable .pte",
+    )
+    ap.add_argument(
+        "--max-sec",
+        type=float,
+        default=15.0,
+        help="longest clip (the playground's window is <= 15 s)",
+    )
+    ap.add_argument(
+        "--encoder-attn",
+        choices=["eager", "et_vk"],
+        default="eager",
+        help="encoder attention: matmul+softmax (default; planned activation memory) or the fused "
+        "et_vk.sdpa op as in the previous export (public runtime: 2 x 72 MB scratch per layer)",
+    )
+    ap.add_argument(
+        "--keep-portable",
+        action="store_true",
+        help="also write the CPU-only portable .pte files",
+    )
+    ap.add_argument(
+        "--runtime-ops",
+        help="optional text file, one registered WebGPU runtime op per line; every delegated op is checked against it",
+    )
+    args = ap.parse_args()
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+    torch.manual_seed(0)
+
+    from transformers import (
+        WhisperFeatureExtractor,
+        WhisperForConditionalGeneration,
+        WhisperTokenizer,
+    )
+
+    snap, digests = fetch_upstream()
+    model = WhisperForConditionalGeneration.from_pretrained(
+        snap, dtype=torch.float32, attn_implementation="eager"
+    ).eval()
+    fe = WhisperFeatureExtractor.from_pretrained(snap)
+    tables = W.HostTables(model, PRECISIONS[args.precision][2])
+    progs, quant_info = build_programs(model, fe, args.precision, args.encoder_attn, tables, args.max_sec)
+    runtime_ops = None
+    if args.runtime_ops:
+        runtime_ops = {
+            l.strip()
+            for l in Path(args.runtime_ops).read_text().splitlines()
+            if l.strip()
+        }
+
+    eps, ptes, files, graphs, checks, io_contract = {}, {}, {}, {}, {}, {}
+    for name in NAMES:
+        t = time.time()
+        wg_mod, port_mod, _ = progs[name]
+        inputs = example_inputs(name)
+        ep = export_one(wg_mod, inputs)
+        prog = _common.lower_webgpu(ep)
+        path = out / f"whisper_{name}.pte"
+        path.unlink(missing_ok=True)  # never write through a hard link shared with another variant
+        path.write_bytes(prog.buffer)
+        eps[name] = ep
+        graphs[name] = _common.delegate_summary(prog.buffer)
+        checks[name] = W.vk_checks(prog.buffer, runtime_ops)
+        io_contract[name] = W.program_io(prog.buffer)
+        files[path.name] = {
+            "bytes": path.stat().st_size,
+            "sha256": _common.sha256_file(path),
+        }
+        if not args.no_validate or args.keep_portable:
+            ptes[name] = _common.lower_portable(export_one(port_mod, inputs)).buffer
+            if args.keep_portable:
+                (out / "portable").mkdir(exist_ok=True)
+                (out / "portable" / f"whisper_{name}_portable.pte").write_bytes(
+                    ptes[name]
+                )
+        del prog
+        print(
+            f"[export] {path.name}: {files[path.name]['bytes']} B, {time.time() - t:.1f} s, "
+            f"checks ok={checks[name]['ok']}, {json.dumps(graphs[name])[:240]}",
+            flush=True,
+        )
+
+    for fname, blob in tables.files().items():
+        (out / fname).unlink(missing_ok=True)
+        (out / fname).write_bytes(blob)
+    (out / "vocab.json").unlink(missing_ok=True)
+    shutil.copyfile(snap / "vocab.json", out / "vocab.json")
+    for fname in [*tables.files(), "vocab.json"]:
+        files[fname] = {
+            "bytes": (out / fname).stat().st_size,
+            "sha256": _common.sha256_file(out / fname),
+        }
+
+    dec_kind, lm_kind, emb_kind = PRECISIONS[args.precision]
+    lm_desc = {
+        "int4": {"config": W.Q4_DESC, "lowered_to": "et_vk.linear_q4gsw (group 64)"},
+        "fp32": {"config": "none", "lowered_to": "aten.linear (2-D fp32)"},
+        "int8 static-act": {"config": W.Q8_HEAD_DESC, "lowered_to": "quantized_decomposed.quantize_per_tensor + et_vk.linear_q8ta_q8csw", **quant_info},
+    }[lm_kind]
+    recipe = {
+        "model": "whisper-base",
+        "precision": args.precision,
+        "upstream": {
+            "model": UPSTREAM["repo"],
+            "revision": UPSTREAM["revision"],
+            "official": True,
+            "license": "apache-2.0 (model card)",
+            "files_sha256": digests,
+            "loader": "transformers.WhisperForConditionalGeneration.from_pretrained(dtype=float32, attn_implementation='eager')",
+        },
+        "versions": _common.versions(),
+        "export": {
+            "api": "torch.export.export(strict=False) -> to_edge_transform_and_lower(partitioner=[WebGPUPartitioner()]) -> to_executorch()",
+            "partitioner": "executorch.backends.webgpu.partitioner.WebGPUPartitioner() (default compile options; wraps VulkanPartitioner; delegate id VulkanBackend)",
+            "model_code": "recipes/_whisper.py wrappers around the transformers modules (weights shared, forward re-expressed): "
+            "MelProgram, EncoderProgram, CrossKVProgram, DecoderSplitProgram, DecodeStreamProgram, LMHeadProgram",
+            "quantization": {
+                "decoder_side_linears": {
+                    "programs": ["cross_kv", "decoder_split", "decode_stream"],
+                    "config": W.Q4_DESC if dec_kind == "int4" else "none (fp32)",
+                    "lowered_to": "et_vk.linear_q4gsw (group 64)" if dec_kind == "int4" else "aten.linear (2-D fp32)",
+                },
+                "lmhead": lm_desc,
+                "fp32_programs": ["mel", "encoder"],
+                "embedding_table": "int8 rowwise (whisper_embed.i8.bin + whisper_embed.scale.f32.bin)"
+                if emb_kind == "int8"
+                else "fp32 (whisper_embed.f32.bin)",
+            },
+            "encoder_attention": args.encoder_attn,
+            "decoder_attention": "et_vk.sdpa (decoder_split self-attention with a [1,8,64,64] additive causal mask "
+            "of 0 / -1e30; cross-attention in decoder_split and decode_stream); decode_stream self-attention = "
+            "llama.update_cache + llama.custom_sdpa, fused by the Vulkan partitioner into sdpa_with_kv_cache + "
+            "et_vk.select_as_symint",
+            "lmhead_rows": f"{W.VOCAB_PADDED}: vocab {W.VOCAB} padded with zero weights and bias {W.PAD_LOGIT} "
+            "(executorch 1.5.1's q4gsw lowering fails for N % 4 != 0; kept for fp32 too so the contract is identical)",
+            "constants": {
+                "max_decoder_rows": W.MAX_DEC,
+                "self_attention_cache": [1, W.KV_LEN, W.N_HEADS, W.HEAD_DIM],
+                "frames": [W.FRAMES, W.N_FFT],
+                "hop": W.HOP,
+                "prefix_en": W.PREFIX_EN,
+            },
+            "host_contract": {
+                "frames": "whisper.js buildFrames: zero-pad pcm to 480000 samples, reflect-pad 200 each side, 3000 x 400 windows at hop 160",
+                "log_mel": "between mel and encoder: x = log10(max(p, 1e-10)); x = max(x, max(x) - 8); x = (x + 4) / 4; "
+                "transpose [1,3000,80] -> [1,80,3000]",
+                "embeddings": ("i8[id] * scale[id]" if emb_kind == "int8" else "f32[id]")
+                + "; decoder_split: rows 0..p = token embeddings (no positions), zero rows after; "
+                "decode_stream: token embedding + pos_embed[p]",
+                "argmax": f"over logits[..., :{W.VOCAB}] (rows {W.VOCAB}..{W.VOCAB_PADDED - 1} are {W.PAD_LOGIT})",
+                "cross_kv": "computed once per 30 s window, then passed as 12 inputs to every decoder call",
+            },
+            "io": io_contract,
+        },
+        "files": files,
+        "graph": graphs,
+        "webgpu_runtime_checks": {
+            "op_list": "checked against --runtime-ops"
+            if runtime_ops
+            else "not checked (no --runtime-ops given)",
+            **checks,
+        },
+        "command": _common.command_line(out),
+    }
+    (out / "recipe.json").write_text(json.dumps(recipe, indent=2) + "\n")
+    print(json.dumps({"files": files}, indent=2), flush=True)
+
+    if not args.no_validate:
+        tok = WhisperTokenizer.from_pretrained(snap)
+        validate(args, out, model, fe, tok, progs, eps, ptes, tables)
+
+
+if __name__ == "__main__":
+    main()

manifest.json

@@ -9,18 +9,13 @@
     },
     {
       "path": "whisper_cross_kv.pte",
-      "bytes": 1801728,
-      "sha256": "9ade21df201932715c97143e59936519ca2680743fa33fc3967f61d97dcbc40d"
+      "bytes": 12610560,
+      "sha256": "6e8078924168c21a863ff662e9ccba55ed86bb3826dabd28fea77010e3151012"
     },
     {
       "path": "whisper_decode_stream.pte",
-      "bytes": 23680256,
-      "sha256": "9b77ad9d5e003b063dcff55eab5f5ac70025beadc2aa7ef4ab1c3994380a72d5"
-    },
-    {
-      "path": "whisper_decoder_split.pte",
-      "bytes": 13719936,
-      "sha256": "84d9427851420bf73d521649e1bb6af52458b36906d9a9a064d6057239e0dd1e"
+      "bytes": 89270912,
+      "sha256": "bc2f33ad7aa164059e819247365e2e0a75a3f1a2973024e4fdc67a254d7faa8d"
     },
     {
       "path": "whisper_embed.i8.bin",
@@ -34,18 +29,18 @@
     },
     {
       "path": "whisper_encoder.pte",
-      "bytes": 82419712,
-      "sha256": "951972490d33f680cb55861e7feb19f1661311f975582bc5074f2acb03855c25"
+      "bytes": 82420996,
+      "sha256": "841e7702ba8fa73594f0b4e1400230d6b686af958628ead6b22919e9a3e27c69"
     },
     {
       "path": "whisper_lmhead.pte",
-      "bytes": 15149056,
-      "sha256": "1dfce892767b535b823742fd3cfabf0ba9ae28ab9a0e54384b32c842faf01ae5"
+      "bytes": 27184000,
+      "sha256": "68577fa240d29923058fd72b94db583f3ff171302ad12834c2b610e04c559f8e"
     },
     {
       "path": "whisper_mel.pte",
-      "bytes": 713536,
-      "sha256": "d0b2759497debae49d05f089c4971d42f38a0ad87c8a45831a2987e0db09b06b"
+      "bytes": 710976,
+      "sha256": "7cae31829487958454c5a14aecfed0845f6320dd480c24883861fa39b07de497"
     },
     {
       "path": "whisper_pos_embed.f32.bin",

whisper_cross_kv.pte

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9ade21df201932715c97143e59936519ca2680743fa33fc3967f61d97dcbc40d
-size 1801728
+oid sha256:6e8078924168c21a863ff662e9ccba55ed86bb3826dabd28fea77010e3151012
+size 12610560

whisper_decode_stream.pte

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9b77ad9d5e003b063dcff55eab5f5ac70025beadc2aa7ef4ab1c3994380a72d5
-size 23680256
+oid sha256:bc2f33ad7aa164059e819247365e2e0a75a3f1a2973024e4fdc67a254d7faa8d
+size 89270912

whisper_decoder_split.pte

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:84d9427851420bf73d521649e1bb6af52458b36906d9a9a064d6057239e0dd1e
-size 13719936

whisper_encoder.pte

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:951972490d33f680cb55861e7feb19f1661311f975582bc5074f2acb03855c25
-size 82419712
+oid sha256:841e7702ba8fa73594f0b4e1400230d6b686af958628ead6b22919e9a3e27c69
+size 82420996

whisper_lmhead.pte

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1dfce892767b535b823742fd3cfabf0ba9ae28ab9a0e54384b32c842faf01ae5
-size 15149056
+oid sha256:68577fa240d29923058fd72b94db583f3ff171302ad12834c2b610e04c559f8e
+size 27184000

whisper_mel.pte

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d0b2759497debae49d05f089c4971d42f38a0ad87c8a45831a2987e0db09b06b
-size 713536
+oid sha256:7cae31829487958454c5a14aecfed0845f6320dd480c24883861fa39b07de497
+size 710976