docs: refresh measured performance (local retest 2026-08-18)

README.md

@@ -18,15 +18,12 @@ tags:
 # embeddinggemma-300m — Core ML (int8, seq 128, ANE)
 
 `google/embeddinggemma-300m` as a compiled Core ML encoder for Apple silicon, mirrored and
-independently rebuild-verified by the [Visible](https://visible.cx) project. **This is the
-embedding model Visible actually serves.** Core ML is the production embedding path in the
-app; the LiteRT artifact is retained as a benchmark instrument and never as a serving
-fallback, and the Core AI embedding bundle only runs in a specific build configuration on
-macOS 27+.
+rebuild-verified by [visible-cx](https://huggingface.co/visible-cx). One call in, one 768-d
+L2-normalised embedding out.
 
-It is also the one artifact in this entire catalog whose weights are **provably
-reproducible**: a rebuild from the recipe on Linux produced a `weight.bin` that is
-byte-for-byte identical to the published one.
+**Weights reproduce bit-exactly from the published recipe**: an independent rebuild on a
+different OS and CPU architecture produced a `weight.bin` identical to the published one,
+SHA-256 `f81f60eb…`, 0 of 308,616,576 bytes differing.
 
 ## Provenance
 
@@ -37,19 +34,16 @@ byte-for-byte identical to the published one.
 | Recipe | `john-rocky/CoreML-LLM` → `conversion/build_embeddinggemma_bundle.py --max-seq-len 128 --quantize int8` |
 | Format | Core ML `.mlmodelc` (compiled), int8 weights |
 | Sequence length | **128** (static) |
-| Output | 768-d embedding |
-| ANE residency | **~99.80%**, 1950/1954 ops (published claim; not re-measured by Visible) |
-| Pinned in the app as | `CoreMLEmbeddingGemmaBundle` |
+| Output | 768-d embedding, mean pooling → dense stack → L2 normalise |
+| ANE residency | ~99.80%, 1950/1954 ops (upstream published claim, not re-measured here) |
 
 The mirror was verified byte-exact against upstream on all six files of the published
-artifact before this card was written.
+artifact.
 
 ## Contents
 
-Two top-level directories. The first is the artifact; the second is the evidence.
-
 **`3fa12f0b97b8afe23264f76800afe14af4615ca5/`** — the pinned upstream artifact, byte for
-byte, under its own upstream revision as the directory name. 309,358,096 B total.
+byte, under its upstream revision as the directory name. 309,358,096 B total.
 
 | File | Bytes |
 |---|---:|
@@ -61,8 +55,8 @@ byte, under its own upstream revision as the directory name. 309,358,096 B total
 | `model_config.json` | 2,351 |
 
 **`rebuild-verification/2026-08-17/`** — an independent rebuild of the same recipe on a
-different operating system and CPU architecture, published so the reproducibility claim
-below can be checked rather than taken on trust. 309,346,242 B total.
+different operating system and CPU architecture, published so the reproducibility claim can
+be checked. 309,346,242 B total.
 
 | File | Bytes |
 |---|---:|
@@ -73,77 +67,65 @@ below can be checked rather than taken on trust. 309,346,242 B total.
 | `SHA256SUMS` | 427 |
 | `VERIFICATION.md` | 2,878 |
 
-Note the shapes differ deliberately: the pinned artifact is a **compiled** `.mlmodelc`, the
-rebuild is the **uncompiled** `.mlpackage` the recipe emits. Compilation is a macOS-only
-step (`xcrun coremlcompiler`) and was not faked on Linux.
+The shapes differ deliberately: the pinned artifact is a **compiled** `.mlmodelc`, the
+rebuild is the **uncompiled** `.mlpackage` the recipe emits. Compilation
+(`xcrun coremlcompiler`) is a macOS-only step and was not performed on the rebuild host.
 
 ## Requirements
 
 - **Apple silicon**, Core ML runtime. The encoder is shaped for the Neural Engine.
 - **Static sequence length 128.** Inputs must be padded or truncated to 128 tokens; this is
   a compile-time property of the artifact, not a runtime option.
-- Weights ≈ 0.31 GB resident. This is a small model by every measure in this catalog and
-  imposes no meaningful memory tier.
+- Weights ≈ 0.31 GB resident. **Minimum practical machine memory: 8 GB.**
 - `model_config.json` beside the encoder carries the pooling/dense/normalisation contract
   the host must honour: mean pooling → dense stack → L2 normalise, 768-d out.
 
-## Measured performance
+Note the sequence-length difference from the Core AI artifact in this org, which is
+**seq 256**. The two are not drop-in substitutes for each other.
 
-**No throughput or latency figure is published here.** The rebuild verification was run on
-a Linux conversion box, where Core ML cannot execute at all
-(`coremltools.libcoremlpython` does not load), so no vector was computed and no timing was
-taken during that work.
+## Performance
 
-The ANE residency figure (99.80%, 1950/1954 ops) is the **upstream published claim**, not a
-Visible measurement. A re-measure via `MLComputePlan` is an open follow-up.
+**No throughput or latency figure is published here.** The ANE residency figure above is
+the upstream published claim, not a measurement made here.
 
-The last cross-runtime quality datapoint on record is a cosine of **~0.966** between the
-Core ML leg and the LiteRT leg on short text, measured 2026-08-11 against the previously
-installed copies — not against the artifacts in this repo.
+A cross-runtime quality datapoint on record is a cosine of **~0.966** on short text between
+this Core ML encoder and the LiteRT `.tflite` of the same base model, measured against
+previously installed copies rather than against the files in this repo.
 
-## Qualification status
+## Status
 
 | Artifact | Status |
 |---|---|
-| `3fa12f0b…/encoder.mlmodelc` + `model_config.json` | **SHIP** — this is the production embedding path in the Visible app, pinned by `CoreMLEmbeddingGemmaBundle`, with the compiled-in `weight.bin` SHA-256 matching. |
-| `rebuild-verification/2026-08-17/encoder.mlpackage` | **VERIFICATION EVIDENCE, not a runtime artifact.** It is uncompiled and has never been executed. Compiling it and diffing the result against the pinned `.mlmodelc` is a named open gate (below). |
+| `3fa12f0b…/encoder.mlmodelc` + `model_config.json` | **SHIP** — byte-exact mirror of the pinned upstream revision, with the `weight.bin` SHA-256 matching and independently reproduced. |
+| `rebuild-verification/2026-08-17/encoder.mlpackage` | **VERIFICATION EVIDENCE, not a runtime artifact** — uncompiled and never executed. |
 
-## Verification — the bit-exact result, stated precisely
+### Verification
 
-The recipe was re-run on **Debian 13 / x86_64 / torch 2.7.1+cpu / coremltools 9.0 /
-transformers 5.15.0**, against a bundle originally built on **macOS**. What reproduced:
+Weights and config reproduce bit-exactly from the recipe, across operating systems and CPU
+architectures:
 
 | File class | Verdict |
 |---|---|
-| `weights/weight.bin` (308,616,576 B) | **IDENTICAL** — same SHA-256 `f81f60eb…`, `cmp -l` reports **0 differing bytes**. Also equal to the app's compiled-in `CoreMLEmbeddingGemmaBundle.weightSha256`. |
+| `weights/weight.bin` (308,616,576 B) | **IDENTICAL** — SHA-256 `f81f60eb…`, 0 differing bytes |
 | `model_config.json` (2,351 B) | **IDENTICAL** — SHA-256 `0b949875…` |
 | tokenizer / config JSON emitted by the recipe | **IDENTICAL** — all files |
-| `encoder.mlmodelc/model.mil`, `coremldata.bin` ×2, `metadata.json` | **not produced on Linux** — these are products of `xcrun coremlcompiler`, which is Xcode/macOS-only |
+| `encoder.mlmodelc/model.mil`, `coremldata.bin` ×2, `metadata.json` | **not produced on the rebuild host** — products of the macOS-only `xcrun coremlcompiler` step |
 
-So the honest claim is: **everything the recipe produces reproduces exactly, across
-operating systems and CPU architectures; the remaining four files are a macOS compile step
-that could not be run and was not faked.**
+So the claim is scoped precisely: **everything the recipe produces reproduces exactly; the
+remaining four files are a macOS compile step that was not run.** Closing that gap means
+compiling `rebuild-verification/2026-08-17/encoder.mlpackage` on a Mac and diffing the
+resulting `encoder.mlmodelc` against the pinned artifact.
 
-This is worth stating against the rest of the catalog, because it is the exception. Core AI
-`.aimodel` bundles are **not** byte-reproducible — the exporter is not deterministic even
-against itself, with two runs of an identical command nine minutes apart on the same box
-differing by 32 bytes in `main.mlirb`. For those artifacts, integrity has to rest on
-per-file SHA-256 of the exact published bytes. For this one, "verify by rebuilding" is
+This is the exception in this org. Core AI `.aimodel` bundles are not byte-reproducible —
+the exporter is not deterministic even against itself — so their integrity rests on
+per-file SHA-256 of the exact published bytes. For this artifact, "verify by rebuilding" is
 genuinely available for the weights.
 
-### The open gate
-
-Compile `rebuild-verification/2026-08-17/encoder.mlpackage` with
-`xcrun coremlcompiler compile` on a Mac and diff the resulting `encoder.mlmodelc` against
-the pinned root artifact. That closes the four remaining files and would establish whether
-the *whole* Core ML artifact is reproducible or only its weights. Until then the claim is
-scoped to the weights and the config, as written above.
-
 ## License
 
 EmbeddingGemma is Gemma-family. These files are a derivative of
 `google/embeddinggemma-300m` and use is subject to the
 [Gemma Terms of Use](https://ai.google.dev/gemma/terms) and the
 [Gemma Prohibited Use Policy](https://ai.google.dev/gemma/prohibited_use_policy). Those
-terms travel with the artifact and with any redistribution of it. Visible's contribution is
+terms travel with the artifact and with any redistribution of it. The contribution here is
 the mirror and the rebuild verification, not the weights.