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

.gitattributes

@@ -34,3 +34,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 model_ctx8960_m512.pte filter=lfs diff=lfs merge=lfs -text
+llama3_2_1b_instruct_q4gsw.pte filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -1,70 +1,111 @@
 LLAMA 3.2 COMMUNITY LICENSE AGREEMENT
-
 Llama 3.2 Version Release Date: September 25, 2024
 
-“Agreement” means the terms and conditions for use, reproduction, distribution and modification of the Llama Materials set forth herein.
-
-
-“Documentation” means the specifications, manuals and documentation accompanying Llama 3.2 distributed by Meta at https://www.llama.com/docs/overview.
-
+“Agreement” means the terms and conditions for use, reproduction, distribution 
+and modification of the Llama Materials set forth herein.
 
-“Licensee” or “you” means you, or your employer or any other person or entity (if you are entering into this Agreement on such person or entity’s behalf), of the age required under applicable laws, rules or regulations to provide legal consent and that has legal authority to bind your employer or such other person or entity if you are entering in this Agreement on their behalf.
+“Documentation” means the specifications, manuals and documentation accompanying Llama 3.2
+distributed by Meta at https://llama.meta.com/doc/overview.
 
+“Licensee” or “you” means you, or your employer or any other person or entity (if you are 
+entering into this Agreement on such person or entity’s behalf), of the age required under
+applicable laws, rules or regulations to provide legal consent and that has legal authority
+to bind your employer or such other person or entity if you are entering in this Agreement
+on their behalf.
 
-“Llama 3.2” means the foundational large language models and software and algorithms, including machine-learning model code, trained model weights, inference-enabling code, training-enabling code, fine-tuning enabling code and other elements of the foregoing distributed by Meta at https://www.llama.com/llama-downloads.
+“Llama 3.2” means the foundational large language models and software and algorithms, including
+machine-learning model code, trained model weights, inference-enabling code, training-enabling code,
+fine-tuning enabling code and other elements of the foregoing distributed by Meta at 
+https://www.llama.com/llama-downloads.
 
+“Llama Materials” means, collectively, Meta’s proprietary Llama 3.2 and Documentation (and 
+any portion thereof) made available under this Agreement.
 
-“Llama Materials” means, collectively, Meta’s proprietary Llama 3.2 and Documentation (and any portion thereof) made available under this Agreement.
+“Meta” or “we” means Meta Platforms Ireland Limited (if you are located in or, 
+if you are an entity, your principal place of business is in the EEA or Switzerland) 
+and Meta Platforms, Inc. (if you are located outside of the EEA or Switzerland). 
 
 
-“Meta” or “we” means Meta Platforms Ireland Limited (if you are located in or, if you are an entity, your principal place of business is in the EEA or Switzerland) and Meta Platforms, Inc. (if you are located outside of the EEA or Switzerland).
-
-
-By clicking “I Accept” below or by using or distributing any portion or element of the Llama Materials, you agree to be bound by this Agreement.
+By clicking “I Accept” below or by using or distributing any portion or element of the Llama Materials,
+you agree to be bound by this Agreement.
 
 
 1. License Rights and Redistribution.
 
-
-    a. Grant of Rights. You are granted a non-exclusive, worldwide, non-transferable and royalty-free limited license under Meta’s intellectual property or other rights owned by Meta embodied in the Llama Materials to use, reproduce, distribute, copy, create derivative works of, and make modifications to the Llama Materials.
-
-
-    b. Redistribution and Use.
-
-
-        i. If you distribute or make available the Llama Materials (or any derivative works thereof), or a product or service (including another AI model) that contains any of them, you shall (A) provide a copy of this Agreement with any such Llama Materials; and (B) prominently display “Built with Llama” on a related website, user interface, blogpost, about page, or product documentation. If you use the Llama Materials or any outputs or results of the Llama Materials to create, train, fine tune, or otherwise improve an AI model, which is distributed or made available, you shall also include “Llama” at the beginning of any such AI model name.
-
-
-        ii. If you receive Llama Materials, or any derivative works thereof, from a Licensee as part of an integrated end user product, then Section 2 of this Agreement will not apply to you.
-
-
-        iii. You must retain in all copies of the Llama Materials that you distribute the following attribution notice within a “Notice” text file distributed as a part of such copies: “Llama 3.2 is licensed under the Llama 3.2 Community License, Copyright © Meta Platforms, Inc. All Rights Reserved.”
-
-
-        iv. Your use of the Llama Materials must comply with applicable laws and regulations (including trade compliance laws and regulations) and adhere to the Acceptable Use Policy for the Llama Materials (available at https://www.llama.com/llama3_2/use-policy), which is hereby incorporated by reference into this Agreement.
-
-2. Additional Commercial Terms. If, on the Llama 3.2 version release date, the monthly active users of the products or services made available by or for Licensee, or Licensee’s affiliates, is greater than 700 million monthly active users in the preceding calendar month, you must request a license from Meta, which Meta may grant to you in its sole discretion, and you are not authorized to exercise any of the rights under this Agreement unless or until Meta otherwise expressly grants you such rights.
-
-
-3. Disclaimer of Warranty. UNLESS REQUIRED BY APPLICABLE LAW, THE LLAMA MATERIALS AND ANY OUTPUT AND RESULTS THEREFROM ARE PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OF ANY KIND, AND META DISCLAIMS ALL WARRANTIES OF ANY KIND, BOTH EXPRESS AND IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OF USING OR REDISTRIBUTING THE LLAMA MATERIALS AND ASSUME ANY RISKS ASSOCIATED WITH YOUR USE OF THE LLAMA MATERIALS AND ANY OUTPUT AND RESULTS.
-
-
-4. Limitation of Liability. IN NO EVENT WILL META OR ITS AFFILIATES BE LIABLE UNDER ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, TORT, NEGLIGENCE, PRODUCTS LIABILITY, OR OTHERWISE, ARISING OUT OF THIS AGREEMENT, FOR ANY LOST PROFITS OR ANY INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL, EXEMPLARY OR PUNITIVE DAMAGES, EVEN IF META OR ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF ANY OF THE FOREGOING.
-
+    a. Grant of Rights. You are granted a non-exclusive, worldwide, 
+non-transferable and royalty-free limited license under Meta’s intellectual property or other rights 
+owned by Meta embodied in the Llama Materials to use, reproduce, distribute, copy, create derivative works 
+of, and make modifications to the Llama Materials.  
+
+    b. Redistribution and Use.  
+
+        i. If you distribute or make available the Llama Materials (or any derivative works thereof), 
+or a product or service (including another AI model) that contains any of them, you shall (A) provide
+a copy of this Agreement with any such Llama Materials; and (B) prominently display “Built with Llama”
+on a related website, user interface, blogpost, about page, or product documentation. If you use the
+Llama Materials or any outputs or results of the Llama Materials to create, train, fine tune, or
+otherwise improve an AI model, which is distributed or made available, you shall also include “Llama”
+at the beginning of any such AI model name.
+
+        ii. If you receive Llama Materials, or any derivative works thereof, from a Licensee as part
+of an integrated end user product, then Section 2 of this Agreement will not apply to you. 
+
+        iii. You must retain in all copies of the Llama Materials that you distribute the 
+following attribution notice within a “Notice” text file distributed as a part of such copies: 
+“Llama 3.2 is licensed under the Llama 3.2 Community License, Copyright © Meta Platforms,
+Inc. All Rights Reserved.”
+
+        iv. Your use of the Llama Materials must comply with applicable laws and regulations
+(including trade compliance laws and regulations) and adhere to the Acceptable Use Policy for
+the Llama Materials (available at https://www.llama.com/llama3_2/use-policy), which is hereby 
+incorporated by reference into this Agreement.
+  
+2. Additional Commercial Terms. If, on the Llama 3.2 version release date, the monthly active users
+of the products or services made available by or for Licensee, or Licensee’s affiliates, 
+is greater than 700 million monthly active users in the preceding calendar month, you must request 
+a license from Meta, which Meta may grant to you in its sole discretion, and you are not authorized to
+exercise any of the rights under this Agreement unless or until Meta otherwise expressly grants you such rights.
+
+3. Disclaimer of Warranty. UNLESS REQUIRED BY APPLICABLE LAW, THE LLAMA MATERIALS AND ANY OUTPUT AND 
+RESULTS THEREFROM ARE PROVIDED ON AN “AS IS” BASIS, WITHOUT WARRANTIES OF ANY KIND, AND META DISCLAIMS
+ALL WARRANTIES OF ANY KIND, BOTH EXPRESS AND IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES
+OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE
+FOR DETERMINING THE APPROPRIATENESS OF USING OR REDISTRIBUTING THE LLAMA MATERIALS AND ASSUME ANY RISKS ASSOCIATED
+WITH YOUR USE OF THE LLAMA MATERIALS AND ANY OUTPUT AND RESULTS.
+
+4. Limitation of Liability. IN NO EVENT WILL META OR ITS AFFILIATES BE LIABLE UNDER ANY THEORY OF LIABILITY, 
+WHETHER IN CONTRACT, TORT, NEGLIGENCE, PRODUCTS LIABILITY, OR OTHERWISE, ARISING OUT OF THIS AGREEMENT, 
+FOR ANY LOST PROFITS OR ANY INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL, EXEMPLARY OR PUNITIVE DAMAGES, EVEN 
+IF META OR ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF ANY OF THE FOREGOING.
 
 5. Intellectual Property.
 
-
-    a. No trademark licenses are granted under this Agreement, and in connection with the Llama Materials, neither Meta nor Licensee may use any name or mark owned by or associated with the other or any of its affiliates, except as required for reasonable and customary use in describing and redistributing the Llama Materials or as set forth in this Section 5(a). Meta hereby grants you a license to use “Llama” (the “Mark”) solely as required to comply with the last sentence of Section 1.b.i. You will comply with Meta’s brand guidelines (currently accessible at https://about.meta.com/brand/resources/meta/company-brand/). All goodwill arising out of your use of the Mark will inure to the benefit of Meta.
-
-
-    b. Subject to Meta’s ownership of Llama Materials and derivatives made by or for Meta, with respect to any derivative works and modifications of the Llama Materials that are made by you, as between you and Meta, you are and will be the owner of such derivative works and modifications.
-
-
-    c. If you institute litigation or other proceedings against Meta or any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Llama Materials or Llama 3.2 outputs or results, or any portion of any of the foregoing, constitutes infringement of intellectual property or other rights owned or licensable by you, then any licenses granted to you under this Agreement shall terminate as of the date such litigation or claim is filed or instituted. You will indemnify and hold harmless Meta from and against any claim by any third party arising out of or related to your use or distribution of the Llama Materials.
-
-
-6. Term and Termination. The term of this Agreement will commence upon your acceptance of this Agreement or access to the Llama Materials and will continue in full force and effect until terminated in accordance with the terms and conditions herein. Meta may terminate this Agreement if you are in breach of any term or condition of this Agreement. Upon termination of this Agreement, you shall delete and cease use of the Llama Materials. Sections 3, 4 and 7 shall survive the termination of this Agreement.
-
-
-7. Governing Law and Jurisdiction. This Agreement will be governed and construed under the laws of the State of California without regard to choice of law principles, and the UN Convention on Contracts for the International Sale of Goods does not apply to this Agreement. The courts of California shall have exclusive jurisdiction of any dispute arising out of this Agreement.
+    a. No trademark licenses are granted under this Agreement, and in connection with the Llama Materials, 
+neither Meta nor Licensee may use any name or mark owned by or associated with the other or any of its affiliates, 
+except as required for reasonable and customary use in describing and redistributing the Llama Materials or as 
+set forth in this Section 5(a). Meta hereby grants you a license to use “Llama” (the “Mark”) solely as required 
+to comply with the last sentence of Section 1.b.i. You will comply with Meta’s brand guidelines (currently accessible 
+at https://about.meta.com/brand/resources/meta/company-brand/). All goodwill arising out of your use of the Mark 
+will inure to the benefit of Meta.
+
+    b. Subject to Meta’s ownership of Llama Materials and derivatives made by or for Meta, with respect to any
+    derivative works and modifications of the Llama Materials that are made by you, as between you and Meta,
+    you are and will be the owner of such derivative works and modifications.
+
+    c. If you institute litigation or other proceedings against Meta or any entity (including a cross-claim or
+    counterclaim in a lawsuit) alleging that the Llama Materials or Llama 3.2 outputs or results, or any portion
+    of any of the foregoing, constitutes infringement of intellectual property or other rights owned or licensable
+    by you, then any licenses granted to you under this Agreement shall terminate as of the date such litigation or
+    claim is filed or instituted. You will indemnify and hold harmless Meta from and against any claim by any third
+    party arising out of or related to your use or distribution of the Llama Materials.
+
+6. Term and Termination. The term of this Agreement will commence upon your acceptance of this Agreement or access
+to the Llama Materials and will continue in full force and effect until terminated in accordance with the terms
+and conditions herein. Meta may terminate this Agreement if you are in breach of any term or condition of this
+Agreement. Upon termination of this Agreement, you shall delete and cease use of the Llama Materials. Sections 3,
+4 and 7 shall survive the termination of this Agreement. 
+
+7. Governing Law and Jurisdiction. This Agreement will be governed and construed under the laws of the State of 
+California without regard to choice of law principles, and the UN Convention on Contracts for the International
+Sale of Goods does not apply to this Agreement. The courts of California shall have exclusive jurisdiction of
+any dispute arising out of this Agreement. 

README.md

@@ -24,8 +24,8 @@ the visitor's GPU. It powers the corresponding demo in the ExecuTorch WebGPU Pla
 
 - **Base model:** [meta-llama/Llama-3.2-1B-Instruct](https://huggingface.co/meta-llama/Llama-3.2-1B-Instruct)
 - **Format:** ExecuTorch `.pte` programs delegated to the WebGPU backend
-- **Quantization:** 4-bit groupwise weights (q4gsw), fp16 KV cache
-- **Total size:** 850.4 MB
+- **Quantization:** 4-bit groupwise weights (q4gsw, group size 64) for all linear layers and the tied token-embedding/output head; fp32 activations and KV cache
+- **Total size:** 709.5 MB
 
 ## About the original model
 
@@ -47,19 +47,23 @@ Out of scope: any use that violates applicable laws or the Acceptable Use Policy
 
 ## What changed in this conversion
 
-- Weights quantized to 4-bit groupwise (q4gsw); the KV cache is fp16
-- Context capped at 8,960 tokens (upstream: 128K)
+- Exported with ExecuTorch's `export_llm` (`model_class=llama3_2`) from the original Meta-format checkpoint (`original/consolidated.00.pth`, bf16), with Llama 3 scaled RoPE (factor 32)
+- All linear layers quantized to 4-bit groupwise weights (q4gsw, group size 64, round to nearest); the token embedding is quantized the same way. Llama 3.2 ties the embedding and the output head, so they quantize to the same bytes and the program stores them once
+- Activations and the KV cache buffers in the program are fp32
+- Context capped at 8,960 tokens (upstream: 128K); at most 512 tokens per forward call
+- 4-bit quantization changes the outputs: on 3 test prompts, greedy text from this program agreed with the fp32 model for the first 6, 8 (the whole answer) and 0 tokens, and gave fluent, on-topic answers in all three
 
 ## Inputs and outputs
 
-- Token IDs in, last-position logits out (vocabulary 128,256); the KV cache lives inside the program; up to 512 new tokens per call
-- Tokenize with the files in `tokenizer/` (the upstream Llama 3.2 tokenizer and chat template)
+- `forward(tokens int64 [1, 1..512], input_pos int64 [1]) -> logits float32 [1, 128256]` (last position only)
+- The KV cache lives inside the program; call it with up to 512 new tokens at a time, then one token per step. Metadata methods: `get_max_seq_len` 513, `get_max_context_len` 8960, `get_n_layers` 16, `get_vocab_size` 128256
+- Tokenize with the files in `tokenizer/` (the upstream Llama 3.2 tokenizer and chat template); stop on token 128001, 128008 or 128009
 
 ## Files
 
 | File | Size | SHA-256 |
 |---|---|---|
-| `model_ctx8960_m512.pte` | 841.7 MB | `66c9d2934daf17fb…` |
+| `llama3_2_1b_instruct_q4gsw.pte` | 700.8 MB | `49de6eec3a54f1f4…` |
 | `tokenizer/config.json` | 877 B | `2febf68cea25bf46…` |
 | `tokenizer/generation_config.json` | 189 B | `88effbb63300dbbc…` |
 | `tokenizer/special_tokens_map.json` | 296 B | `6f38c73729248f6c…` |
@@ -71,8 +75,8 @@ 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 its greedy output matched the CPU reference token for token on 3 test prompts. 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.
 
@@ -80,8 +84,11 @@ Requirements: a browser with WebGPU enabled. The language models use the `shader
 
 ## 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:** `meta-llama/Llama-3.2-1B-Instruct` at revision `9213176726f574b556790deb65791e0c5aa438b6` (official)
+- **Weights source:** downloaded from the public mirror `LIF1014/ptdbench-Llama-3.2-1B-Instruct` @ `828e5f37c833a02415416260d5a93780fd41d10e`; the gated official repo was not downloaded. Each of the 9 files taken from the mirror (checkpoint `original/consolidated.00.pth`, `original/params.json`, the 5 tokenizer/config files, `LICENSE.txt`, `USE_POLICY.md`) was verified against the hash the official repo publishes for it at the pinned revision (LFS sha256 for the checkpoint, `fc17d497df5e4175b3a8acb4f5865b26f7fc1b009b25bef814b95fde10e8a1f3`; git blob SHA-1 for the small files), so the bytes used are the official ones. `export/llama-3.2-1b-instruct.py` repeats this check on every run
+- **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/llama-3.2-1b-instruct.py --out out/llama-3.2-1b-instruct` (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/_llm.py

@@ -0,0 +1,157 @@
+"""Shared export path for the Qwen LLM recipes: pinned HF snapshot -> ExecuTorch checkpoint
+-> export_llm (Vulkan partitioner, which WebGPUPartitioner wraps unchanged) -> .pte.
+
+Graph contract (matches the internal WebGPU LLM artifacts): forward(tokens[1, <=prefill_max]
+int64, input_pos[1] int64) -> logits[1, vocab] float32 for the last position, KV cache inside the
+program (fp32 buffers, max_context_length positions), 4-bit groupwise weight-only linears
+(et_vk.linear_q4gsw) and 4-bit groupwise embedding (et_vk.embedding_q4gsw).
+"""
+
+import importlib
+import json
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import _common
+
+SHIMS = Path(__file__).resolve().parent / "_shims"
+
+TOKENIZER_FILES = [
+    "tokenizer.json",
+    "tokenizer_config.json",
+    "vocab.json",
+    "merges.txt",
+    "generation_config.json",
+    "config.json",
+    "LICENSE",
+]
+
+
+def export(
+    *, name, upstream_repo, revision, model_class, params, converter, max_context, args
+):
+    from huggingface_hub import snapshot_download
+
+    out = Path(args.out).resolve()
+    work = out / "_work"
+    work.mkdir(parents=True, exist_ok=True)
+    snap = Path(
+        snapshot_download(
+            upstream_repo,
+            revision=revision,
+            allow_patterns=["*.safetensors", "*.json", "merges.txt", "LICENSE"],
+        )
+    )
+
+    sys.path.insert(0, str(SHIMS))
+    env = {**os.environ, "PYTHONPATH": os.pathsep.join(filter(None, [str(SHIMS), os.environ.get("PYTHONPATH")]))}
+    ckpt = work / "checkpoint.pth"
+    if not ckpt.exists():
+        importlib.import_module(converter).convert_weights(str(snap), str(ckpt))
+    params_path = work / "params.json"
+    params_path.write_text(json.dumps(params, indent=2) + "\n")
+
+    output_name = f"{name}.pte"
+    overrides = [
+        f"base.model_class={model_class}",
+        f"base.checkpoint={ckpt}",
+        f"base.params={params_path}",
+        "model.use_kv_cache=true",
+        "model.use_sdpa_with_kv_cache=true",
+        "model.enable_dynamic_shape=true",
+        "model.dtype_override=fp32",
+        f"export.max_seq_length={args.prefill_max + 1}",
+        f"export.max_context_length={max_context}",
+        f"export.output_dir={out}",
+        f"export.output_name={out / output_name}",
+        "quantization.qmode=4w",
+        f"quantization.group_size={args.group_size}",
+        f"quantization.embedding_quantize='4,{args.group_size}'",
+        "backend.vulkan.enabled=true",
+    ]
+    cmd = [
+        sys.executable,
+        "-m",
+        "executorch.extension.llm.export.export_llm",
+        *overrides,
+    ]
+    print("+", " ".join(shlex.quote(c) for c in cmd), flush=True)
+    subprocess.run(cmd, check=True, env=env)
+
+    pte = out / output_name
+    tok_dir = out / "tokenizer"
+    tok_dir.mkdir(exist_ok=True)
+    tokenizer_files = {}
+    for f in TOKENIZER_FILES:
+        if (snap / f).exists():
+            shutil.copyfile(snap / f, tok_dir / f)
+            tokenizer_files[f] = _common.sha256_file(tok_dir / f)
+    shutil.rmtree(work)
+
+    data = pte.read_bytes()
+    recipe = {
+        "model": name,
+        "upstream": {
+            "model": upstream_repo,
+            "revision": revision,
+            "official": True,
+            "safetensors_sha256": {
+                p.name: _common.sha256_file(p)
+                for p in sorted(snap.glob("*.safetensors"))
+            },
+        },
+        "versions": _common.versions(),
+        "export": {
+            "api": "python -m executorch.extension.llm.export.export_llm (hydra overrides below)",
+            "overrides": [_common.scrub(o, out).replace(str(work.resolve()), "<work>") for o in overrides],
+            "checkpoint_conversion": f"{converter}.convert_weights(<snapshot>, checkpoint.pth)",
+            "import_shim": "recipes/_shims/torchtune (re-exports executorch.examples.models.checkpoint.get_mapped_key; torchtune itself is not installed)",
+            "params": params,
+            "partitioner": "VulkanPartitioner via backend.vulkan.enabled (WebGPUPartitioner is a pass-through wrapper of it; delegate id VulkanBackend)",
+            "inputs": [
+                {
+                    "name": "tokens",
+                    "shape": [1, f"1..{args.prefill_max}"],
+                    "dtype": "int64",
+                },
+                {"name": "input_pos", "shape": [1], "dtype": "int64"},
+            ],
+            "outputs": [
+                {
+                    "name": "logits",
+                    "shape": [1, params["vocab_size"]],
+                    "dtype": "float32",
+                    "note": "last position only",
+                }
+            ],
+            "prefill_max": args.prefill_max,
+            "max_seq_len_metadata": args.prefill_max + 1,
+            "max_context_length": max_context,
+            "dtype": "float32 activations",
+            "quantization": f"4-bit groupwise weight-only linears (torchao IntxWeightOnlyConfig int4, group {args.group_size}) and 4-bit groupwise embedding (group {args.group_size}); output head quantized too",
+            "kv_cache": "fp32 buffers in the program; fp16 KV is a runtime option of the WebGPU runtime (et_set_kv_f16), not an export flag",
+        },
+        "files": {
+            pte.name: {"bytes": len(data), "sha256": _common.sha256_file(pte)},
+            **{f"tokenizer/{k}": {"sha256": v} for k, v in tokenizer_files.items()},
+        },
+        "graph": _common.delegate_summary(data),
+        "command": _common.command_line(out),
+    }
+    (out / "recipe.json").write_text(json.dumps(recipe, indent=2) + "\n")
+    print(json.dumps({"files": recipe["files"], "graph": recipe["graph"]}, indent=2))
+
+
+def add_args(ap, max_context):
+    ap.add_argument("--out", required=True, help="output directory")
+    ap.add_argument(
+        "--prefill-max", type=int, default=512, help="max tokens per forward call"
+    )
+    ap.add_argument(
+        "--max-context", type=int, default=max_context, help="KV cache length"
+    )
+    ap.add_argument("--group-size", type=int, default=64)

export/_shims/torchtune/__init__.py

@@ -0,0 +1,8 @@
+"""Import shim for `torchtune.models.convert_weights.get_mapped_key`.
+
+executorch 1.5.1's examples/models/qwen2_5 imports that single helper from torchtune, which
+ExecuTorch pins to a GitHub commit (unreachable from the export host); the PyPI and nightly
+torchtune builds do not import against torchao 0.18. ExecuTorch ships an equivalent helper in
+executorch.examples.models.checkpoint (already used by its qwen3 converter); this shim
+re-exports it. Only on PYTHONPATH while the Qwen2.5 recipe runs.
+"""

export/_shims/torchtune/models/convert_weights.py

@@ -0,0 +1 @@
+from executorch.examples.models.checkpoint import get_mapped_key  # noqa: F401

export/llama-3.2-1b-instruct.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""Llama 3.2 1B Instruct -> ExecuTorch WebGPU (4-bit groupwise weights, KV cache in program).
+
+Same export path as the Qwen recipes (_llm.py): export_llm with the Vulkan partitioner (which
+WebGPUPartitioner wraps unchanged), qmode=4w group 64, 4-bit embedding, fp32 activations and fp32
+KV buffers, prefill up to 512 tokens, 8960-token context. Program contract (same as the previous
+artifact): forward(tokens[1, 1..512] int64, input_pos[1] int64) -> logits[1, 128256] float32 for
+the last position.
+
+Weights: the Meta-format checkpoint `original/consolidated.00.pth` + `original/params.json` of
+meta-llama/Llama-3.2-1B-Instruct at a pinned revision (Llama 3.2 Community License). The upstream
+repo is gated. `--source auto` (default) downloads from it when the token has access, otherwise
+from a public mirror. Either way every file is checked against the hashes Hugging Face publishes
+for the *official* repo at the pinned revision (LFS sha256 for large files, git blob sha1 for small
+ones; both are visible without access), so the bytes used are the official bytes.
+"""
+
+import argparse
+import hashlib
+import json
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import _common  # noqa: E402
+import _llm  # noqa: E402
+
+OFFICIAL = {
+    "repo": "meta-llama/Llama-3.2-1B-Instruct",
+    "revision": "9213176726f574b556790deb65791e0c5aa438b6",
+}
+# Public mirror whose files are byte-identical to OFFICIAL at the pinned revision (checked below).
+MIRROR = {
+    "repo": "LIF1014/ptdbench-Llama-3.2-1B-Instruct",
+    "revision": "828e5f37c833a02415416260d5a93780fd41d10e",
+}
+# Hashes Hugging Face reports for OFFICIAL@revision (HfApi.model_info(files_metadata=True)).
+# lfs: sha256 of the file; blob: git blob sha1 (sha1(b"blob <len>\0" + content)).
+FILES = {
+    "original/consolidated.00.pth": {
+        "lfs": "fc17d497df5e4175b3a8acb4f5865b26f7fc1b009b25bef814b95fde10e8a1f3"
+    },
+    "original/params.json": {"blob": "9cd8dbdf2dc6f4d8abb60bdb5ce64f4bec2fdfd9"},
+    "tokenizer.json": {"blob": "5cc5f00a5b203e90a27a3bd60d1ec393b07971e8"},
+    "tokenizer_config.json": {"blob": "4ff488a165e900e5129cda7c20ab32d568d2a475"},
+    "special_tokens_map.json": {"blob": "02ee80b6196926a5ad790a004d9efd6ab1ba6542"},
+    "config.json": {"blob": "3e3aaf51a035cb5092d9f6827a0dc074657ba88c"},
+    "generation_config.json": {"blob": "75ae08310d6d23df373ee2644b497192b3cce6d8"},
+    "LICENSE.txt": {"blob": "085b47c1575cb889b7024030e60b78f54f0b8c9e"},
+    "USE_POLICY.md": {"blob": "ac3c5f21b9779e3da0677d6d3c587778fe3a331e"},
+}
+# Shipped next to the .pte for the playground's tokenizer (transformers.js) and license notice.
+TOKENIZER_FILES = [
+    "tokenizer.json",
+    "tokenizer_config.json",
+    "special_tokens_map.json",
+    "config.json",
+    "generation_config.json",
+    "LICENSE.txt",
+    "USE_POLICY.md",
+]
+NAME = "llama3_2_1b_instruct_q4gsw"
+MODEL_CLASS = "llama3_2"
+
+
+def git_blob_sha1(path):
+    data = Path(path).read_bytes()
+    return hashlib.sha1(b"blob %d\0" % len(data) + data).hexdigest()
+
+
+def check(path, want):
+    if "lfs" in want:
+        got = _common.sha256_file(path)
+        return got == want["lfs"], {"sha256": got}
+    got = git_blob_sha1(path)
+    return got == want["blob"], {"git_blob_sha1": got}
+
+
+def official_metadata():
+    """Cross-check the pinned hashes against what the Hub reports now (no access needed)."""
+    from huggingface_hub import HfApi
+
+    info = HfApi().model_info(
+        OFFICIAL["repo"], revision=OFFICIAL["revision"], files_metadata=True
+    )
+    live = {s.rfilename: s for s in info.siblings}
+    for f, want in FILES.items():
+        s = live[f]
+        if "lfs" in want and (s.lfs is None or s.lfs.sha256 != want["lfs"]):
+            sys.exit(f"official {f}: Hub reports {s.lfs} != pinned {want}")
+        if "blob" in want and s.blob_id != want["blob"]:
+            sys.exit(f"official {f}: Hub reports blob {s.blob_id} != pinned {want}")
+    return info.sha
+
+
+def fetch(source):
+    from huggingface_hub import hf_hub_download
+    from huggingface_hub.errors import GatedRepoError
+
+    def get(repo):
+        return {
+            f: Path(hf_hub_download(repo["repo"], f, revision=repo["revision"]))
+            for f in FILES
+        }
+
+    used = None
+    if source in ("auto", "official"):
+        try:
+            paths, used = get(OFFICIAL), OFFICIAL
+        except GatedRepoError as e:
+            if source == "official":
+                raise
+            print(
+                f"official repo not accessible ({str(e).splitlines()[-1][:120]}); using mirror",
+                flush=True,
+            )
+    if used is None:
+        paths, used = get(MIRROR), MIRROR
+    verified = {}
+    for f, p in paths.items():
+        ok, got = check(p, FILES[f])
+        if not ok:
+            sys.exit(
+                f"{used['repo']}@{used['revision']}:{f} {got} does not match official {FILES[f]}"
+            )
+        verified[f] = got
+    return paths, used, verified
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    _llm.add_args(ap, max_context=8960)
+    ap.add_argument(
+        "--embedding-group-size",
+        type=int,
+        default=None,
+        help="group size of the 4-bit embedding (default: --group-size; the previous artifact used 32)",
+    )
+    ap.add_argument("--source", choices=["auto", "official", "mirror"], default="auto")
+    args = ap.parse_args()
+
+    out = Path(args.out).resolve()
+    work = out / "_work"
+    work.mkdir(parents=True, exist_ok=True)
+    official_sha = official_metadata()
+    paths, used, verified = fetch(args.source)
+    params = json.loads(paths["original/params.json"].read_text())
+
+    sys.path.insert(0, str(_llm.SHIMS))
+    env = {
+        **os.environ,
+        "PYTHONPATH": os.pathsep.join(
+            filter(None, [str(_llm.SHIMS), os.environ.get("PYTHONPATH")])
+        ),
+    }
+    ckpt = work / "checkpoint.pth"
+    if ckpt.is_symlink() or ckpt.exists():
+        ckpt.unlink()
+    ckpt.symlink_to(paths["original/consolidated.00.pth"])
+    params_path = work / "params.json"
+    shutil.copyfile(paths["original/params.json"], params_path)
+
+    emb_group = args.embedding_group_size or args.group_size
+    output_name = f"{NAME}.pte"
+    overrides = [
+        f"base.model_class={MODEL_CLASS}",
+        f"base.checkpoint={ckpt}",
+        f"base.params={params_path}",
+        "model.use_kv_cache=true",
+        "model.use_sdpa_with_kv_cache=true",
+        "model.enable_dynamic_shape=true",
+        "model.dtype_override=fp32",
+        f"export.max_seq_length={args.prefill_max + 1}",
+        f"export.max_context_length={args.max_context}",
+        f"export.output_dir={out}",
+        f"export.output_name={out / output_name}",
+        "quantization.qmode=4w",
+        f"quantization.group_size={args.group_size}",
+        f"quantization.embedding_quantize='4,{emb_group}'",
+        "backend.vulkan.enabled=true",
+    ]
+    cmd = [
+        sys.executable,
+        "-m",
+        "executorch.extension.llm.export.export_llm",
+        *overrides,
+    ]
+    print("+", " ".join(shlex.quote(c) for c in cmd), flush=True)
+    subprocess.run(cmd, check=True, env=env)
+
+    pte = out / output_name
+    tok_dir = out / "tokenizer"
+    tok_dir.mkdir(exist_ok=True)
+    tokenizer_files = {}
+    for f in TOKENIZER_FILES:
+        shutil.copyfile(paths[f], tok_dir / f)
+        tokenizer_files[f] = _common.sha256_file(tok_dir / f)
+    shutil.rmtree(work)
+
+    data = pte.read_bytes()
+    recipe = {
+        "model": NAME,
+        "upstream": {
+            "model": OFFICIAL["repo"],
+            "revision": OFFICIAL["revision"],
+            "official": True,
+            "license": "Llama 3.2 Community License (tokenizer/LICENSE.txt, tokenizer/USE_POLICY.md); Built with Llama",
+            "files": {f: {**FILES[f], **verified[f]} for f in FILES},
+            "hub_revision_checked": official_sha,
+            "downloaded_from": {
+                **used,
+                "note": "all files verified byte-identical to the official hashes above",
+            },
+        },
+        "versions": _common.versions(),
+        "export": {
+            "api": "python -m executorch.extension.llm.export.export_llm (hydra overrides below)",
+            "overrides": [
+                _common.scrub(o, out).replace(str(work.resolve()), "<work>")
+                for o in overrides
+            ],
+            "checkpoint": "original/consolidated.00.pth (Meta format, bf16; no conversion), params = original/params.json",
+            "params": params,
+            "rope": "llama3 scaled RoPE, rope_scale_factor=32 (set by ExecuTorch for model_class llama3_2 when use_scaled_rope)",
+            "partitioner": "VulkanPartitioner via backend.vulkan.enabled (WebGPUPartitioner is a pass-through wrapper of it; delegate id VulkanBackend)",
+            "inputs": [
+                {
+                    "name": "tokens",
+                    "shape": [1, f"1..{args.prefill_max}"],
+                    "dtype": "int64",
+                },
+                {"name": "input_pos", "shape": [1], "dtype": "int64"},
+            ],
+            "outputs": [
+                {
+                    "name": "logits",
+                    "shape": [1, params["vocab_size"]],
+                    "dtype": "float32",
+                    "note": "last position only",
+                }
+            ],
+            "prefill_max": args.prefill_max,
+            "max_seq_len_metadata": args.prefill_max + 1,
+            "max_context_length": args.max_context,
+            "dtype": "float32 activations",
+            "quantization": f"4-bit groupwise weight-only linears (torchao IntxWeightOnlyConfig int4, group {args.group_size}) and 4-bit groupwise embedding (group {emb_group}); output head quantized too",
+            "kv_cache": "fp32 buffers in the program; fp16 KV is a runtime option of the WebGPU runtime (enable_f16_kv_cache / et_set_kv_f16), not an export flag",
+        },
+        "files": {
+            pte.name: {"bytes": len(data), "sha256": _common.sha256_file(pte)},
+            **{f"tokenizer/{k}": {"sha256": v} for k, v in tokenizer_files.items()},
+        },
+        "graph": _common.delegate_summary(data),
+        "command": _common.command_line(out),
+    }
+    (out / "recipe.json").write_text(json.dumps(recipe, indent=2) + "\n")
+    print(json.dumps({"files": recipe["files"], "graph": recipe["graph"]}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

export/recipe.json

@@ -0,0 +1,186 @@
+{
+  "model": "llama3_2_1b_instruct_q4gsw",
+  "upstream": {
+    "model": "meta-llama/Llama-3.2-1B-Instruct",
+    "revision": "9213176726f574b556790deb65791e0c5aa438b6",
+    "official": true,
+    "license": "Llama 3.2 Community License (tokenizer/LICENSE.txt, tokenizer/USE_POLICY.md); Built with Llama",
+    "files": {
+      "original/consolidated.00.pth": {
+        "lfs": "fc17d497df5e4175b3a8acb4f5865b26f7fc1b009b25bef814b95fde10e8a1f3",
+        "sha256": "fc17d497df5e4175b3a8acb4f5865b26f7fc1b009b25bef814b95fde10e8a1f3"
+      },
+      "original/params.json": {
+        "blob": "9cd8dbdf2dc6f4d8abb60bdb5ce64f4bec2fdfd9",
+        "git_blob_sha1": "9cd8dbdf2dc6f4d8abb60bdb5ce64f4bec2fdfd9"
+      },
+      "tokenizer.json": {
+        "blob": "5cc5f00a5b203e90a27a3bd60d1ec393b07971e8",
+        "git_blob_sha1": "5cc5f00a5b203e90a27a3bd60d1ec393b07971e8"
+      },
+      "tokenizer_config.json": {
+        "blob": "4ff488a165e900e5129cda7c20ab32d568d2a475",
+        "git_blob_sha1": "4ff488a165e900e5129cda7c20ab32d568d2a475"
+      },
+      "special_tokens_map.json": {
+        "blob": "02ee80b6196926a5ad790a004d9efd6ab1ba6542",
+        "git_blob_sha1": "02ee80b6196926a5ad790a004d9efd6ab1ba6542"
+      },
+      "config.json": {
+        "blob": "3e3aaf51a035cb5092d9f6827a0dc074657ba88c",
+        "git_blob_sha1": "3e3aaf51a035cb5092d9f6827a0dc074657ba88c"
+      },
+      "generation_config.json": {
+        "blob": "75ae08310d6d23df373ee2644b497192b3cce6d8",
+        "git_blob_sha1": "75ae08310d6d23df373ee2644b497192b3cce6d8"
+      },
+      "LICENSE.txt": {
+        "blob": "085b47c1575cb889b7024030e60b78f54f0b8c9e",
+        "git_blob_sha1": "085b47c1575cb889b7024030e60b78f54f0b8c9e"
+      },
+      "USE_POLICY.md": {
+        "blob": "ac3c5f21b9779e3da0677d6d3c587778fe3a331e",
+        "git_blob_sha1": "ac3c5f21b9779e3da0677d6d3c587778fe3a331e"
+      }
+    },
+    "hub_revision_checked": "9213176726f574b556790deb65791e0c5aa438b6",
+    "downloaded_from": {
+      "repo": "LIF1014/ptdbench-Llama-3.2-1B-Instruct",
+      "revision": "828e5f37c833a02415416260d5a93780fd41d10e",
+      "note": "all files verified byte-identical to the official hashes above"
+    }
+  },
+  "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": "python -m executorch.extension.llm.export.export_llm (hydra overrides below)",
+    "overrides": [
+      "base.model_class=llama3_2",
+      "base.checkpoint=<out>/_work/checkpoint.pth",
+      "base.params=<out>/_work/params.json",
+      "model.use_kv_cache=true",
+      "model.use_sdpa_with_kv_cache=true",
+      "model.enable_dynamic_shape=true",
+      "model.dtype_override=fp32",
+      "export.max_seq_length=513",
+      "export.max_context_length=8960",
+      "export.output_dir=<out>",
+      "export.output_name=<out>/llama3_2_1b_instruct_q4gsw.pte",
+      "quantization.qmode=4w",
+      "quantization.group_size=64",
+      "quantization.embedding_quantize='4,64'",
+      "backend.vulkan.enabled=true"
+    ],
+    "checkpoint": "original/consolidated.00.pth (Meta format, bf16; no conversion), params = original/params.json",
+    "params": {
+      "dim": 2048,
+      "n_layers": 16,
+      "n_heads": 32,
+      "n_kv_heads": 8,
+      "vocab_size": 128256,
+      "ffn_dim_multiplier": 1.5,
+      "multiple_of": 256,
+      "norm_eps": 1e-05,
+      "rope_theta": 500000.0,
+      "use_scaled_rope": true
+    },
+    "rope": "llama3 scaled RoPE, rope_scale_factor=32 (set by ExecuTorch for model_class llama3_2 when use_scaled_rope)",
+    "partitioner": "VulkanPartitioner via backend.vulkan.enabled (WebGPUPartitioner is a pass-through wrapper of it; delegate id VulkanBackend)",
+    "inputs": [
+      {
+        "name": "tokens",
+        "shape": [
+          1,
+          "1..512"
+        ],
+        "dtype": "int64"
+      },
+      {
+        "name": "input_pos",
+        "shape": [
+          1
+        ],
+        "dtype": "int64"
+      }
+    ],
+    "outputs": [
+      {
+        "name": "logits",
+        "shape": [
+          1,
+          128256
+        ],
+        "dtype": "float32",
+        "note": "last position only"
+      }
+    ],
+    "prefill_max": 512,
+    "max_seq_len_metadata": 513,
+    "max_context_length": 8960,
+    "dtype": "float32 activations",
+    "quantization": "4-bit groupwise weight-only linears (torchao IntxWeightOnlyConfig int4, group 64) and 4-bit groupwise embedding (group 64); output head quantized too",
+    "kv_cache": "fp32 buffers in the program; fp16 KV is a runtime option of the WebGPU runtime (enable_f16_kv_cache / et_set_kv_f16), not an export flag"
+  },
+  "files": {
+    "llama3_2_1b_instruct_q4gsw.pte": {
+      "bytes": 734868736,
+      "sha256": "49de6eec3a54f1f45a785152375edafec07cb0fd879a142100340fd2765c40a7"
+    },
+    "tokenizer/tokenizer.json": {
+      "sha256": "79e3e522635f3171300913bb421464a87de6222182a0570b9b2ccba2a964b2b4"
+    },
+    "tokenizer/tokenizer_config.json": {
+      "sha256": "9823dcfdc1121869029da45192238e85cf44f0b232a6d9dc20e4fe6f4242a14e"
+    },
+    "tokenizer/special_tokens_map.json": {
+      "sha256": "6f38c73729248f6c127296386e3cdde96e254636cc58b4169d3fd32328d9a8ec"
+    },
+    "tokenizer/config.json": {
+      "sha256": "2febf68cea25bf4611be02b7536f2488a5ba523bb1134986e3610152abe74fdb"
+    },
+    "tokenizer/generation_config.json": {
+      "sha256": "88effbb63300dbbc7390143fbbdd9d9fa50587b37e8bfd16c8c90d4970a74a36"
+    },
+    "tokenizer/LICENSE.txt": {
+      "sha256": "0b4284c1f87029e67654c7953afa16279961632cf73dcfe33374c4c2f298fa35"
+    },
+    "tokenizer/USE_POLICY.md": {
+      "sha256": "40e2777d7faa6beaf98400654170f414d8ab29b921b5163ad4ea0a1d39894201"
+    }
+  },
+  "graph": {
+    "non_delegated_kernels": {},
+    "delegates": [
+      {
+        "id": "VulkanBackend",
+        "ops": {
+          "et_vk.prepack.default": 2,
+          "sym_size.int": 1,
+          "et_vk.embedding_q4gsw.default": 1,
+          "et_vk.select_as_symint.default": 2,
+          "add": 1,
+          "aten.slice_copy.Tensor": 2,
+          "et_vk.rms_norm.default": 33,
+          "et_vk.linear_q4gsw.default": 113,
+          "aten.view_copy.default": 128,
+          "et_vk.apply_rotary_emb.default": 16,
+          "sdpa_with_kv_cache.default": 16,
+          "aten.add.Tensor": 32,
+          "aten.sigmoid.default": 16,
+          "aten.mul.Tensor": 32,
+          "aten.select_copy.int": 1
+        },
+        "inputs": 2,
+        "outputs": 1
+      }
+    ]
+  },
+  "command": "python recipes/llama-3.2-1b-instruct.py --out out/llama-3.2-1b-instruct"
+}

export/requirements.txt

@@ -0,0 +1,15 @@
+# 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

model_ctx8960_m512.pte → llama3_2_1b_instruct_q4gsw.pte

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:66c9d2934daf17fb25fe52a7c2f01616142eef48532c88c2f97aa710817176ea
-size 882609536
+oid sha256:49de6eec3a54f1f45a785152375edafec07cb0fd879a142100340fd2765c40a7
+size 734868736

manifest.json

@@ -3,9 +3,9 @@
   "repo": "executorch-community/Llama-3.2-1B-Instruct-ExecuTorch-WebGPU",
   "files": [
     {
-      "path": "model_ctx8960_m512.pte",
-      "bytes": 882609536,
-      "sha256": "66c9d2934daf17fb25fe52a7c2f01616142eef48532c88c2f97aa710817176ea"
+      "path": "llama3_2_1b_instruct_q4gsw.pte",
+      "bytes": 734868736,
+      "sha256": "49de6eec3a54f1f45a785152375edafec07cb0fd879a142100340fd2765c40a7"
     },
     {
       "path": "tokenizer/config.json",