[ET-VK][CI] Add end-to-end quantized LLM coverage

Summary:

## Rationale

Add the seven LLM recipes used by internal GPU CI to the existing OSS NVIDIA
workflow: Qwen3-0.6B, five Llama3.2-1B configurations, and Phi4 Mini. SwiftShader
cannot exercise their required quantized compute features.

Use CUDA's shared model export/build/run pattern. Select pinned public HF
checkpoints, prepare them with existing model utilities, invoke the existing
LLM exporter, check called Vulkan delegates and required operator families,
and validate greedy native output. Quantized Llama embeddings also retain the
770 MiB artifact limit.

Run the seven recipes sequentially in one NVIDIA job to avoid repeating setup
and compilation. Build llama-vulkan once and pass the existing runner override
to each shared test invocation. Continue after individual failures, report an
aggregate failure, and retain per-configuration logs/results without model PTEs.

Override HF_HUB_CACHE together with HF_HOME so the GPU runner's read-only
shared-cache mount cannot intercept uncached downloads. A regression executes
the actual workflow cache setup and acquires a real Hugging Face file lock.

The HF converter is named convert_hf_to_meta. Its CLI exposes hf-to-meta,
unsloth-to-meta, and load-and-convert-unsloth-to-meta. The downloader exposes
snapshot and download-and-convert; the latter accepts a MODULE:FUNCTION callback.
Library conversion/cache APIs retain their existing behavior.

## Review order

Read vulkan.yml and the shared export/run scripts first, then the HF/Llama
preparation and PTE checker. Continue with the Release Vulkan Make/CMake path
and installed-package Boost dependency, then the Vulkan CI regression suites
and their CPU CI wiring. The GPU job owns end-to-end harness coverage;
focused artifact/API guards and the real-cache regression live together under
.ci/scripts/tests/vulkan.

| Area | Before | After |
|---|---|---|
| OSS Vulkan GPU CI | Model/operator coverage without an LLM answer gate | One setup/build job runs all seven pinned recipes sequentially |
| Shared scripts | CUDA/Metal/XNNPACK dispatch | Also supports the selected Vulkan recipes |
| Llama preparation | Local Unsloth LoRA conversion wrapper | Full HF conversion through TorchTune and optional parameter output; all functions exposed through CLI |
| Native build | No llama-vulkan Make target | Release Vulkan installation plus the existing Llama runner build |
| Installed package | Boost target references could be unresolved | Discover Boost only when the exported Vulkan interface needs it |

Authored with OpenAI Codex.

Test Plan:

## Observed Results

The 28 Python regression checks pass after consolidating the GPU workflow.
Temporary orchestration validation passed five cases: success, export failure,
native failure, build failure, and setup failure. It executes the actual workflow
shell and shared runner script, stubbing external downloads/build/native compute.
The seven recipe pairs match the former matrix exactly. Shell syntax and edited
file Lintrunner pass. The new single-job NVIDIA run is pending; earlier seven-job
GPU results are historical.

| Correctness validation | Environment | Observed result |
|---|---|---|
| Vulkan CI Python suites, Llama converter tests, existing CUDA workflow tests | Isolated current-pin Python environment | 28 passed, 0 failed |
| Temporary sequential orchestration | Actual shell/shared script, external commands stubbed | 5 passed; failures propagate and later recipes execute |
| CMake package producer/consumer suite | macOS, real configure/build/install | 3 passed, 0 failed |
| Seven before/after export recipe traces and metadata | Real shared scripts with command stubs | All seven identical |
| Renamed PTE checker | Actual saved Qwen PTE | Passed; called VulkanBackend and required families found |
| Seven earlier shared native LLM cases | Qwen: S24/Adreno 750; Llama/Phi: Pixel 9 Pro XL/Mali-G715 | Seven passed expected answers and native exit checks |
| Fresh Qwen export plus shared native execution after exporter reuse | S24/Adreno 750 | Passed |
| make llama-vulkan | Isolated macOS build, Boost enabled; CoreML/ASR disabled locally | Passed |
| Lintrunner on edited files and new/moved CI tests | Local | Passed |
| Shell syntax, whitespace, complete-patch reverse check | Local | Passed |
| Real HF cache lock regression | macOS, inherited read-only cache | Failed before fix; passed afterward |
| NVIDIA workflow after the cache fix, before test-only cleanup | NVIDIA A10G | All seven LLM jobs, existing NVIDIA operator/model job, and Windows Vulkan build passed |
| Linux/macOS unit jobs before test-only cleanup | Release/default/editable | All six passed |

| Performance validation | Result |
|---|---|
| Operator performance tests | Not run; no operator implementation change |
| End-to-end latency/memory A/B against parent/public ancestor | Not run; this adds correctness coverage, with no performance claim |

## Reproduction Guide

### Checkout and development dependencies

Install Git and Conda (Miniforge installers are available at
https://github.com/conda-forge/miniforge/releases). On Linux install a C++
toolchain; on macOS install Xcode command-line tools with xcode-select --install.
For NVIDIA inference, install a compatible NVIDIA Vulkan driver. The existing
setup script selects and checks the hardware ICD.

```bash
git clone --recurse-submodules https://github.com/pytorch/executorch.git
cd executorch
git checkout ssjia/vulkan-llm-ci
git submodule update --init --recursive
conda create -y -n etvk-ci python=3.11
conda activate etvk-ci
conda install -y -c conda-forge cmake ninja glslc rust
CMAKE_ARGS="-DEXECUTORCH_BUILD_VULKAN=ON -DEXECUTORCH_BUILD_KERNELS_LLM_AOT=ON" \
  PYTHON_EXECUTABLE=python ./install_executorch.sh
python -m pip install pytest pytest-xdist
```

On Linux, run the Vulkan dependency setup before installation. Select real-gpu
for NVIDIA runtime testing, or the default setup for software-driver host
preparation/export-only testing:

```bash
source .ci/scripts/setup-vulkan-linux-deps.sh real-gpu
```

### CPU regression tests

These create their own fixtures; no model downloads are needed. Export guards
use synthetic program objects, conversion tests use real tensors, and the CMake
suite builds real small package producers/consumers.
The workflow-cache regression also resolves the actual HF cache constant and
attempts a real lock, rather than replacing the downloader with a stub.

```bash
python -m pytest -q .ci/scripts/tests/vulkan \
  .ci/scripts/tests/test_cuda_workflow.py \
  examples/models/llama/tests/test_convert_weights.py
bash .ci/scripts/tests/vulkan/test_vulkan_cmake_package.sh
```

### Generate all model artifacts

The shared script downloads pinned public checkpoints, copies their tokenizers,
creates exact prompt/answer files, and checks required Vulkan lowering and size.
This generation stage does not require NVIDIA inference.

```bash
ET_ARTIFACT_DIR="$PWD/ci-repro/models"
mkdir -p "$ET_ARTIFACT_DIR"
while read -r model quant; do
  name=$(printf '%s' "$model" | tr / _)
  bash .ci/scripts/export_model_artifact.sh vulkan "$model" "$quant" \
    "$ET_ARTIFACT_DIR/$name/$quant"
done <<'CASES'
Qwen/Qwen3-0.6B quantized-8da4w-fp16-embedding
unsloth/Llama-3.2-1B-Instruct quantized-8da4w
unsloth/Llama-3.2-1B-Instruct quantized-8da4w-fp16
unsloth/Llama-3.2-1B-Instruct quantized-8da4w-embedding
unsloth/Llama-3.2-1B-Instruct quantized-8da4w-fp16-embedding
unsloth/Llama-3.2-1B-Instruct quantized-int4-weight-only
microsoft/Phi-4-mini-instruct quantized-8da4w-embedding
CASES
```

### Linux/NVIDIA single-job reproduction

Use a Linux NVIDIA Vulkan host with the development environment above. Extract
and execute the actual workflow shell, which performs common setup/build once,
then runs all seven cases. It writes results.tsv and per-case logs to the artifact
directory and deletes each PTE after testing.

```bash
export RUNNER_TEMP="$PWD/ci-repro/scratch"
export RUNNER_ARTIFACT_DIR="$PWD/ci-repro/results"
mkdir -p "$RUNNER_TEMP" "$RUNNER_ARTIFACT_DIR"
python - <<'PY'
from pathlib import Path
import yaml
workflow = yaml.safe_load(Path('.github/workflows/vulkan.yml').read_text())
Path('ci-repro/vulkan-llm-job.sh').write_text(
    workflow['jobs']['test-model-vulkan-e2e']['with']['script']
)
PY
bash ci-repro/vulkan-llm-job.sh
cat "$RUNNER_ARTIFACT_DIR/results.tsv"
```

### Reproduce local orchestration validation

These checks execute the actual workflow shell and shared test script. The
fixture substitutes environment setup, package installation, model download,
compilation, and native GPU computation. Actual NVIDIA correctness remains
covered by the CI job above.

```bash
export ET_VALIDATION_DIR="$PWD/ci-repro/orchestration"
mkdir -p "$ET_VALIDATION_DIR"
cat > "$ET_VALIDATION_DIR/expected-cases.json" <<'JSON'
[
  [
    "Qwen/Qwen3-0.6B",
    "quantized-8da4w-fp16-embedding"
  ],
  [
    "unsloth/Llama-3.2-1B-Instruct",
    "quantized-8da4w"
  ],
  [
    "unsloth/Llama-3.2-1B-Instruct",
    "quantized-8da4w-fp16"
  ],
  [
    "unsloth/Llama-3.2-1B-Instruct",
    "quantized-8da4w-embedding"
  ],
  [
    "unsloth/Llama-3.2-1B-Instruct",
    "quantized-8da4w-fp16-embedding"
  ],
  [
    "unsloth/Llama-3.2-1B-Instruct",
    "quantized-int4-weight-only"
  ],
  [
    "microsoft/Phi-4-mini-instruct",
    "quantized-8da4w-embedding"
  ]
]
JSON
cat > "$ET_VALIDATION_DIR/validate_job.py" <<'PY'
import json
import os
from pathlib import Path
import shutil
import subprocess
import tempfile

import yaml

REPO = Path.cwd()
OUTPUT = Path(os.environ['ET_VALIDATION_DIR'])
job = yaml.safe_load((REPO / '.github/workflows/vulkan.yml').read_text())['jobs']['test-model-vulkan-e2e']
assert 'strategy' not in job
script = job['with']['script']
expected = json.loads((OUTPUT / 'expected-cases.json').read_text())
cases = [line.split() for line in script.split("done <<'MODELS'\n", 1)[1].split('\nMODELS', 1)[0].splitlines()]
assert cases == expected

def executable(path, contents):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text('#!/bin/bash\nset -e\n' + contents)
    path.chmod(0o755)

observations = []
for failure in ('none', 'export', 'native', 'build', 'setup'):
    with tempfile.TemporaryDirectory(prefix='vulkan-sequential-') as directory:
        root = Path(directory)
        workspace = root / 'workspace'
        workspace.mkdir()
        scripts = workspace / '.ci/scripts'
        scripts.mkdir(parents=True)
        shutil.copyfile(REPO / '.ci/scripts/test_model_e2e.sh', scripts / 'test_model_e2e.sh')
        tools = root / 'bin'
        tools.mkdir()
        trace = root / 'trace'
        scratch = root / 'scratch'
        scratch.mkdir()
        artifacts = root / 'artifacts'
        artifacts.mkdir()
        executable(scripts / 'setup-vulkan-linux-deps.sh', '''
printf 'setup\n' >> "$TRACE"
if [ "$FAILURE" = setup ]; then return 11; fi
''')
        executable(workspace / 'install_executorch.sh', '''
printf 'install\n' >> "$TRACE"
''')
        executable(tools / 'pip', 'printf "pip\\n" >> "$TRACE"\n')
        executable(tools / 'python', 'printf "[]\\n"\n')
        executable(tools / 'vulkaninfo', 'printf "GPU probe\\n"\n')
        executable(tools / 'uname', 'printf "Linux\\n"\n')
        executable(tools / 'make', '''
printf 'make %s\n' "$*" >> "$TRACE"
if [ "$FAILURE" = build ]; then exit 13; fi
mkdir -p cmake-out/examples/models/llama
cat > cmake-out/examples/models/llama/llama_main <<'RUNNER'
#!/bin/bash
set -e
printf 'native %s\n' "$*" >> "$TRACE"
if [ "$FAILURE" = native ] && [[ "$*" == *"$FAIL_CASE"* ]]; then
  echo 'native failure' >&2
  exit 7
fi
echo 'The capital of France is Paris'
RUNNER
chmod +x cmake-out/examples/models/llama/llama_main
''')
        executable(scripts / 'export_model_artifact.sh', '''
printf 'export %s %s\n' "$2" "$3" >> "$TRACE"
if [ "$FAILURE" = export ] && [[ "$4" == *"$FAIL_CASE"* ]]; then
  echo 'export failure' >&2
  exit 9
fi
printf 'pte' > "$4/model.pte"
printf '{}' > "$4/tokenizer.json"
printf '{}' > "$4/metadata.json"
printf 'prompt' > "$4/prompt.txt"
printf 'The capital of France is Paris\n' > "$4/expected_output.txt"
''')
        result = subprocess.run(
            ['bash', '-c', script],
            cwd=workspace,
            env={**os.environ, 'PATH': str(tools) + ':' + os.environ['PATH'],
                 'RUNNER_TEMP': str(scratch), 'RUNNER_ARTIFACT_DIR': str(artifacts),
                 'TRACE': str(trace), 'FAILURE': failure,
                 'FAIL_CASE': 'unsloth_Llama-3.2-1B-Instruct-quantized-8da4w-embedding'},
            capture_output=True, text=True,
        )
        (OUTPUT / f'{failure}.log').write_text(result.stdout + result.stderr)
        actions = trace.read_text().splitlines()
        assert actions.count('setup') == 1
        if failure == 'setup':
            assert result.returncode == 11
            assert actions == ['setup']
        else:
            assert actions.count('install') == 1
            assert actions.count('make llama-vulkan') == 1
            if failure == 'build':
                assert result.returncode == 13
                assert not any(a.startswith('export') for a in actions)
            else:
                assert result.returncode == (0 if failure == 'none' else 1)
                assert [a.split()[1:] for a in actions if a.startswith('export ')] == expected
                native = [a for a in actions if a.startswith('native ')]
                assert len(native) == (6 if failure == 'export' else 7)
                results = (artifacts / 'results.tsv').read_text().splitlines()[1:]
                assert [r.split('\t')[:2] for r in results] == expected
                statuses = [r.split('\t')[2] for r in results]
                assert statuses.count('FAIL') == (0 if failure == 'none' else 1)
                for model, quant in expected:
                    case_artifacts = artifacts / (model.replace('/', '_') + '-' + quant)
                    assert (case_artifacts / 'test.log').is_file()
                    if failure != 'export' or quant != 'quantized-8da4w-embedding' or model.startswith('microsoft'):
                        assert (case_artifacts / 'metadata.json').is_file()
                assert not list(artifacts.rglob('*.pte'))
                assert not list(scratch.rglob('*.pte'))
        observations.append({'scenario': failure, 'exit_code': result.returncode, 'passed': True})
        print(f'{failure}: passed, exit {result.returncode}')
(OUTPUT / 'local-job-validation.json').write_text(json.dumps(observations, indent=2) + '\n')
PY
python "$ET_VALIDATION_DIR/validate_job.py"
```

### Android native correctness reproduction

Install Android Studio from https://developer.android.com/studio. In SDK
Manager install Android SDK Platform-Tools and NDK 29.0.13846066. Set
ET_ANDROID_SDK to the SDK Location shown by SDK Manager and ET_DEVICE to the
serial reported by adb devices. Enable USB debugging and authorize the host.
Use S24 for Qwen and Pixel 9 Pro XL for the larger Llama/Phi cases, matching the
recorded device sweep.

Build a static Android runtime/runner from this checkout:

```bash
ET_NDK="$ET_ANDROID_SDK/ndk/29.0.13846066"
ET_ANDROID_BUILD="$PWD/ci-repro/android-core"
ET_ANDROID_INSTALL="$PWD/ci-repro/android-install"
ET_ANDROID_RUNNER="$PWD/ci-repro/android-runner"
cmake -S . -B "$ET_ANDROID_BUILD" -G Ninja \
  -DCMAKE_TOOLCHAIN_FILE="$ET_NDK/build/cmake/android.toolchain.cmake" \
  -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-26 \
  -DANDROID_STL=c++_static -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_INSTALL_PREFIX="$ET_ANDROID_INSTALL" -DPYTHON_EXECUTABLE="$(command -v python)" \
  -DEXECUTORCH_BUILD_VULKAN=ON -DEXECUTORCH_BUILD_EXTENSION_DATA_LOADER=ON \
  -DEXECUTORCH_BUILD_EXTENSION_FLAT_TENSOR=ON -DEXECUTORCH_BUILD_EXTENSION_MODULE=ON \
  -DEXECUTORCH_BUILD_EXTENSION_TENSOR=ON -DEXECUTORCH_BUILD_EXTENSION_LLM=ON \
  -DEXECUTORCH_BUILD_EXTENSION_LLM_RUNNER=ON \
  -DEXECUTORCH_BUILD_KERNELS_LLM=ON -DEXECUTORCH_BUILD_KERNELS_QUANTIZED=ON \
  -DEXECUTORCH_BUILD_KERNELS_OPTIMIZED=ON -DEXECUTORCH_BUILD_XNNPACK=ON
cmake --build "$ET_ANDROID_BUILD" --target install --parallel 4
cmake -S examples/models/llama -B "$ET_ANDROID_RUNNER" -G Ninja \
  -DCMAKE_TOOLCHAIN_FILE="$ET_NDK/build/cmake/android.toolchain.cmake" \
  -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-26 \
  -DANDROID_STL=c++_static -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_FIND_ROOT_PATH="$ET_ANDROID_INSTALL" -DPYTHON_EXECUTABLE="$(command -v python)"
cmake --build "$ET_ANDROID_RUNNER" --target llama_main --parallel 4
```

Stage and run one generated artifact; repeat with the other directories/device
as appropriate. Modern adb preserves the remote native exit code. Keep stdout
and stderr separate so diagnostic text cannot satisfy the answer check.

```bash
ET_MODEL_DIR="$ET_ARTIFACT_DIR/Qwen_Qwen3-0.6B/quantized-8da4w-fp16-embedding"
ET_REMOTE=/data/local/tmp/etvk_llm_ci
adb -s "$ET_DEVICE" shell mkdir -p "$ET_REMOTE"
adb -s "$ET_DEVICE" push "$ET_ANDROID_RUNNER/llama_main" "$ET_REMOTE/llama_main"
adb -s "$ET_DEVICE" shell chmod +x "$ET_REMOTE/llama_main"
for file in model.pte tokenizer.json prompt.txt; do
  adb -s "$ET_DEVICE" push "$ET_MODEL_DIR/$file" "$ET_REMOTE/$file"
done
adb -s "$ET_DEVICE" shell "$ET_REMOTE/llama_main" \
  --model_path "$ET_REMOTE/model.pte" --tokenizer_path "$ET_REMOTE/tokenizer.json" \
  --prompt_file "$ET_REMOTE/prompt.txt" --temperature 0 --max_new_tokens 50 \
  > "$ET_MODEL_DIR/runner.stdout" 2> "$ET_MODEL_DIR/runner.stderr"
grep -Fiw -- "$(cat "$ET_MODEL_DIR/expected_output.txt")" "$ET_MODEL_DIR/runner.stdout"
```

No performance tests were run. There are no latency regression thresholds to
reproduce in this change.

Reviewers:

Author: SS-JIA

.ci/scripts/export_model_artifact.sh

@@ -5,16 +5,16 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-# Export model to CUDA/Metal/XNNPACK format with optional quantization
+# Export model to CUDA/Metal/XNNPACK/Vulkan format with optional quantization
 
 show_help() {
   cat << EOF
 Usage: export_model_artifact.sh <device> <hf_model> [quant_name] [output_dir] [mode]
 
-Export a HuggingFace model to CUDA/Metal/XNNPACK format with optional quantization.
+Export a HuggingFace model to CUDA/Metal/XNNPACK/Vulkan format with optional quantization.
 
 Arguments:
-  device       cuda, metal, or xnnpack (required)
+  device       cuda, metal, xnnpack, or vulkan (required)
 
   hf_model     HuggingFace model ID (required)
                Supported models:
@@ -26,14 +26,20 @@ Arguments:
                  - nvidia/parakeet-tdt
                  - facebook/dinov2-small-imagenet1k-1-layer
                  - meta-models/Muse-Glimmer-30B-GGUF
+                 - Qwen/Qwen3-0.6B
+                 - unsloth/Llama-3.2-1B-Instruct
+                 - microsoft/Phi-4-mini-instruct
 
   quant_name   Quantization type (optional, default: non-quantized)
                Options:
                  - non-quantized
                  - quantized-int4-tile-packed (CUDA only)
-                 - quantized-int4-weight-only (CUDA only)
+                 - quantized-int4-weight-only (CUDA/Vulkan)
                  - quantized-int4-metal (Metal only)
-                 - quantized-8da4w (XNNPACK only)
+                 - quantized-8da4w (XNNPACK/Vulkan)
+                 - quantized-8da4w-fp16 (Vulkan only)
+                 - quantized-8da4w-embedding (Vulkan only)
+                 - quantized-8da4w-fp16-embedding (Vulkan only)
                  - kquant-17gb (Muse Glimmer only)
                  - kquant-dynamic (Muse Glimmer only)
 
@@ -85,6 +91,9 @@ QUANT_NAME="${3:-non-quantized}"
 OUTPUT_DIR="${4:-.}"
 MODE="${5:-}"
 
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+EXECUTORCH_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+
 # Validate mode if specified
 if [ -n "$MODE" ]; then
   case "$MODE" in
@@ -118,15 +127,18 @@ case "$DEVICE" in
     ;;
   metal)
     ;;
-  xnnpack)
+  xnnpack|vulkan)
     ;;
   *)
     echo "Error: Unsupported device '$DEVICE'"
-    echo "Supported devices: cuda, cuda-windows, metal, xnnpack"
+    echo "Supported devices: cuda, cuda-windows, metal, xnnpack, vulkan"
     exit 1
     ;;
 esac
 
+CHECKPOINT_SHA256=""
+EXPORT_METADATA=""
+
 # Determine model configuration based on HF model ID
 case "$HF_MODEL" in
   mistralai/Voxtral-Mini-3B-2507)
@@ -168,6 +180,41 @@ case "$HF_MODEL" in
     EXTRA_PIP=""
     PREPROCESSOR_FEATURE_SIZE=""
     PREPROCESSOR_OUTPUT=""
+    if [ "$DEVICE" = "vulkan" ]; then
+      test "$QUANT_NAME" = quantized-8da4w-fp16-embedding
+      MODEL_NAME=qwen3_0_6b
+      REVISION=c1899de289a04d12100db370d81485cdf75e47ca
+      CONVERTER=executorch.examples.models.qwen3.convert_weights
+      PARAMS="$EXECUTORCH_ROOT/examples/models/qwen3/config/0_6b_config.json"
+      PROMPT=$'<|im_start|>user\nWhat is the capital of France?<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n'
+      EXPECTED_OUTPUT=Paris
+    fi
+    ;;
+  unsloth/Llama-3.2-1B-Instruct)
+    if [ "$DEVICE" != "vulkan" ]; then
+      echo "Error: $HF_MODEL is only supported with Vulkan"
+      exit 1
+    fi
+    MODEL_NAME=llama3_2
+    REVISION=5a8abab4a5d6f164389b1079fb721cfab8d7126c
+    CONVERTER=executorch.examples.models.llama.convert_weights
+    CHECKPOINT_SHA256=1ff795ff6a07e6a68085d206fb84417da2f083f68391c2843cd2b8ac6df8538f
+    EXPORT_METADATA='{"append_eos_to_prompt":0,"get_bos_id":128000,"get_eos_ids":[128009,128001]}'
+    PROMPT=$'<|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\nWhat is the capital of France?<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n'
+    EXPECTED_OUTPUT="The capital of France is Paris"
+    ;;
+  microsoft/Phi-4-mini-instruct)
+    if [ "$DEVICE" != "vulkan" ]; then
+      echo "Error: $HF_MODEL is only supported with Vulkan"
+      exit 1
+    fi
+    test "$QUANT_NAME" = quantized-8da4w-embedding
+    MODEL_NAME=phi_4_mini
+    REVISION=cfbefacb99257ffa30c83adab238a50856ac3083
+    CONVERTER=executorch.examples.models.phi_4_mini.convert_weights
+    PARAMS="$EXECUTORCH_ROOT/examples/models/phi_4_mini/config/config.json"
+    PROMPT=$'<|user|>\nWhat is the capital of France?<|end|>\n<|assistant|>\n'
+    EXPECTED_OUTPUT="The capital of France is Paris"
     ;;
   nvidia/parakeet-tdt)
     MODEL_NAME="parakeet"
@@ -232,6 +279,10 @@ case "$HF_MODEL" in
     ;;
 esac
 
+QMODE=8da4w
+FORCE_FP16=false
+EMBEDDING_QUANTIZE=""
+
 # Determine quantization args based on quant name
 case "$QUANT_NAME" in
   non-quantized)
@@ -250,6 +301,7 @@ case "$QUANT_NAME" in
       exit 1
     fi
     EXTRA_ARGS="--qlinear_encoder 4w"
+    QMODE=4w
     ;;
   quantized-int4-metal)
     if [ "$DEVICE" != "metal" ]; then
@@ -259,12 +311,25 @@ case "$QUANT_NAME" in
     EXTRA_ARGS="--qlinear fpa4w --qlinear_encoder fpa4w"
     ;;
   quantized-8da4w)
-    if [ "$DEVICE" != "xnnpack" ]; then
-      echo "Error: quantized-8da4w is only supported with xnnpack device"
+    if [ "$DEVICE" != "xnnpack" ] && [ "$DEVICE" != "vulkan" ]; then
+      echo "Error: quantized-8da4w is only supported with xnnpack or vulkan device"
       exit 1
     fi
     EXTRA_ARGS="--qlinear 8da4w --qlinear_group_size 32 --qlinear_encoder 8da4w --qlinear_encoder_group_size 32"
     ;;
+  quantized-8da4w-fp16|quantized-8da4w-embedding|quantized-8da4w-fp16-embedding)
+    if [ "$DEVICE" != "vulkan" ]; then
+      echo "Error: Quantization '$QUANT_NAME' is only supported with Vulkan"
+      exit 1
+    fi
+    case "$QUANT_NAME" in
+      *-fp16*) FORCE_FP16=true ;;
+    esac
+    case "$QUANT_NAME" in
+      *-embedding) EMBEDDING_QUANTIZE=4,64 ;;
+    esac
+    EXTRA_ARGS=""
+    ;;
   kquant-17gb|kquant-dynamic)
     if [ "$HF_MODEL" != "meta-models/Muse-Glimmer-30B-GGUF" ]; then
       echo "Error: Quantization '$QUANT_NAME' can only be used with Muse Glimmer model"
@@ -295,6 +360,82 @@ if [ "$MODEL_NAME" = "muse_glimmer" ]; then
   fi
 fi
 
+if [ "$DEVICE" = "vulkan" ]; then
+  case "$MODEL_NAME" in
+    qwen3_0_6b|llama3_2|phi_4_mini) ;;
+    *) echo "Error: Unsupported Vulkan model: $HF_MODEL"; exit 1 ;;
+  esac
+  case "$QUANT_NAME" in
+    quantized-8da4w|quantized-8da4w-fp16|quantized-8da4w-embedding|quantized-8da4w-fp16-embedding|quantized-int4-weight-only) ;;
+    *) echo "Error: Unsupported Vulkan quantization: $QUANT_NAME"; exit 1 ;;
+  esac
+  mkdir -p "$OUTPUT_DIR"
+  OUTPUT_DIR="$(cd "$OUTPUT_DIR" && pwd)"
+  (
+    cd "$EXECUTORCH_ROOT"
+    MAX_SIZE_MIB=""
+    if [ "$MODEL_NAME" = "llama3_2" ] && [ -n "$EMBEDDING_QUANTIZE" ]; then MAX_SIZE_MIB=770; fi
+    HASH_ARGS=(--metadata-path "$OUTPUT_DIR/metadata.json")
+    if [ -n "${CHECKPOINT_SHA256:-}" ]; then HASH_ARGS+=(--expected-sha256 "$CHECKPOINT_SHA256"); fi
+    python - "$OUTPUT_DIR" "$HF_MODEL" "$REVISION" "$QUANT_NAME" "$QMODE" "$FORCE_FP16" \
+      "$EMBEDDING_QUANTIZE" "$MAX_SIZE_MIB" "$PROMPT" "$EXPECTED_OUTPUT" <<'PY'
+import json
+import sys
+from pathlib import Path
+
+output, model, revision, variant, qmode, fp16, embedding, size, prompt, expected = sys.argv[1:]
+metadata = {
+    "model": model, "revision": revision, "variant": variant, "quantization": qmode,
+    "group_size": 64, "embedding_quantize": embedding, "dtype": "fp32",
+    "vulkan_force_fp16": fp16 == "true", "max_seq_length": 2048, "max_context_length": 2048,
+    "use_kv_cache": True, "use_sdpa_with_kv_cache": True, "max_size_mib": int(size) if size else None,
+    "prompt": prompt, "expected": expected, "temperature": 0, "max_new_tokens": 50,
+}
+if model == "unsloth/Llama-3.2-1B-Instruct":
+    metadata["original_model"] = "meta-llama/Llama-3.2-1B-Instruct"
+output = Path(output)
+(output / "metadata.json").write_text(json.dumps(metadata, indent=2) + "\n")
+(output / "prompt.txt").write_text(prompt)
+(output / "expected_output.txt").write_text(expected + "\n")
+PY
+    SNAPSHOT=$(python -m executorch.examples.models.llama.hf_download snapshot "$HF_MODEL" \
+      --revision "$REVISION" "${HASH_ARGS[@]}" \
+      2> "$OUTPUT_DIR/download.log")
+    cp "$SNAPSHOT/tokenizer.json" "$SNAPSHOT/tokenizer_config.json" "$OUTPUT_DIR/"
+    VULKAN_CHECKPOINT_DIR=$(mktemp -d "${RUNNER_TEMP:-/tmp}/vulkan_llm_XXXXXX")
+    trap 'rm -rf "$VULKAN_CHECKPOINT_DIR"' EXIT
+    CONVERT_ARGS=("$SNAPSHOT" "$VULKAN_CHECKPOINT_DIR/checkpoint.pth")
+    if [ "$MODEL_NAME" = "llama3_2" ]; then
+      PARAMS="$OUTPUT_DIR/params.json"
+      CONVERT_ARGS=(hf-to-meta "${CONVERT_ARGS[@]}" --params-output "$PARAMS")
+    fi
+    python -m "$CONVERTER" "${CONVERT_ARGS[@]}" > "$OUTPUT_DIR/convert.log" 2>&1
+    VULKAN_EXPORT_ARGS=(
+      "base.model_class=$MODEL_NAME" "base.checkpoint=\"$VULKAN_CHECKPOINT_DIR/checkpoint.pth\""
+      "base.params=\"$PARAMS\"" "base.tokenizer_path=\"$OUTPUT_DIR/tokenizer.json\""
+      model.dtype_override=fp32 model.use_kv_cache=true model.use_sdpa_with_kv_cache=true
+      model.enable_dynamic_shape=true backend.vulkan.enabled=true "backend.vulkan.force_fp16=$FORCE_FP16"
+      "quantization.qmode=$QMODE" quantization.group_size=64
+      export.max_seq_length=2048 export.max_context_length=2048
+      "export.output_dir=\"$OUTPUT_DIR\"" "export.output_name=\"$OUTPUT_DIR/model.pte\"" debug.verbose=true
+    )
+    if [ -n "$EMBEDDING_QUANTIZE" ]; then
+      VULKAN_EXPORT_ARGS+=("quantization.embedding_quantize=\"$EMBEDDING_QUANTIZE\"")
+    fi
+    if [ -n "${EXPORT_METADATA:-}" ]; then VULKAN_EXPORT_ARGS+=("base.metadata='$EXPORT_METADATA'"); fi
+    rm -f "$OUTPUT_DIR/model.pte"
+    python -m extension.llm.export.export_llm "${VULKAN_EXPORT_ARGS[@]}" > "$OUTPUT_DIR/export.log" 2>&1
+    test -f "$OUTPUT_DIR/model.pte"
+    python - "$OUTPUT_DIR/model.pte" "$QMODE" "$EMBEDDING_QUANTIZE" "$MAX_SIZE_MIB" <<'PY'
+import sys
+from executorch.backends.vulkan.test.utils import verify_vulkan_llm_pte
+
+verify_vulkan_llm_pte(sys.argv[1], sys.argv[2], bool(sys.argv[3]), int(sys.argv[4]) if sys.argv[4] else None)
+PY
+  )
+  exit 0
+fi
+
 # Downloads and compiler caches go in scratch dirs outside OUTPUT_DIR because the CI job
 # templates upload OUTPUT_DIR even when the job fails. A failed export also empties
 # OUTPUT_DIR, but only if it started out empty, so a local run with output_dir=. cannot