Add verified Jeff W8 classification size option

JeffDecision-L128-W8.mlpackage/Data/com.apple.CoreML/model.mlmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f6c1c290d3723229bf5e6c22f9fa9db187957f33ed72b3063ebbf88c8073e6f
+size 443616

JeffDecision-L128-W8.mlpackage/Data/com.apple.CoreML/weights/weight.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:10bd21357d7313872abd964923b2483c817dddc66e0ea667d10c262dcc834aae
+size 487930560

JeffDecision-L128-W8.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "415259F0-F9D2-4CC8-9488-BF11BF376148": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        },
+        "41CD2FD7-844B-4EEC-A662-26FFDB616B0A": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        }
+    },
+    "rootModelIdentifier": "41CD2FD7-844B-4EEC-A662-26FFDB616B0A"
+}

README.md

@@ -41,4 +41,8 @@ PY
 
 Four real source-checkpoint fixtures cover billing, technical support, a three-label intent choice and yes/no classification. The mathematical decision wrapper matched native logits within **3.82e-6**. Tracing-only patches matched native logits exactly on those fixtures. The exported FP16 Core ML model preserved all four chosen labels with maximum absolute logit error **0.1139**. FP32 Core ML is a diagnostic control with four-of-four agreement and maximum logit error **3.44e-5**; the FP32 package is not included because it is much larger. Full Decision Index quality, additional input lengths, other task heads and broad latency/ANE performance have not been evaluated. See `native-parity.json` and `coreml-parity-fp16.json`.
 
+An optional `JeffDecision-L128-W8.mlpackage` compresses the FP16 package's trained embedding and linear constants using per-channel symmetric int8. Its 488,374,793-byte package (versus 922,812,014 bytes FP16) retained the chosen label on all four source-checkpoint fixtures with maximum absolute logit error **0.129469**, below the predeclared 0.25 gate. Choose it by passing that package path to `JeffCoreML`. On a small battery-powered Apple M5 Pro probe, W8 had no demonstrated full-request speed advantage: All-compute p50 was 10.07 ms for W8 and 10.12 ms for FP16, with an outlier in W8's eight-call p95. Forcing CPU plus Neural Engine was about 19 ms for both. This is a size option with four-fixture validation, not a broad quality benchmark. Exact artifact hashes are in `reports/w8-validation.json`; see `tools/decision-coreml-profile/RESULTS.md` in the repository for timing scope and placement details.
+
+When using `huggingface_hub.snapshot_download`, pass `local_dir="./jeff-coreml"` and point `JeffCoreML` there. Core ML compilation on the tested macOS release rejected a symlinked Hub-cache weight file; a materialized local directory avoids that path issue.
+
 This conversion is derived from the Apache-2.0 GLiFormer weights and [Transformers](https://github.com/huggingface/transformers) DeBERTa implementation. Jeff's decision adapter code is MIT licensed; the helper source here retains attribution. The model card makes no claim that this conversion is faster or more accurate than another model on a benchmark.

publish.py

@@ -0,0 +1,103 @@
+"""Publish the locally validated Jeff Core ML artifact to its own HF repo."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import shutil
+from pathlib import Path
+
+from huggingface_hub import HfApi, snapshot_download
+
+from export import REVISION, SOURCE
+
+REPO_ID = "FluidInference/jeff-coreml"
+W8_PACKAGE = "JeffDecision-L128-W8.mlpackage"
+REQUIRED = (
+    "README.md",
+    "LICENSE",
+    "assets.lock.json",
+    "jeff_decision.py",
+    "trace_compat.py",
+    "export.py",
+    "verify.py",
+    "runtime.py",
+    "quantize.py",
+    "probe-native.py",
+    "pyproject.toml",
+    "uv.lock",
+)
+TOKENIZER = ("gliner_config.json", "tokenizer.json", "tokenizer_config.json")
+
+
+def package_file_hashes(package: Path) -> dict[str, str]:
+    hashes = {}
+    for file in sorted(package.rglob("*")):
+        if not file.is_file():
+            continue
+        sha = hashlib.sha256()
+        with file.open("rb") as stream:
+            for block in iter(lambda: stream.read(1024 * 1024), b""):
+                sha.update(block)
+        hashes[file.relative_to(package).as_posix()] = sha.hexdigest()
+    return hashes
+
+
+def validate_w8_report(report: dict) -> None:
+    if report.get("source_revision") != REVISION or report.get("package") != W8_PACKAGE:
+        raise ValueError("W8 report does not identify the pinned checkpoint and package")
+    if report.get("native_fixture_count") != 4 or report.get("native_choice_agreement") != 4:
+        raise ValueError("W8 report does not preserve all four native decisions")
+    if report.get("max_logit_error", float("inf")) > 0.25:
+        raise ValueError("W8 report exceeds the 0.25 logit-error gate")
+    if len(report.get("package_files_sha256", {})) != 3:
+        raise ValueError("W8 report lacks the complete package file hashes")
+
+
+def stage() -> Path:
+    source = Path(snapshot_download(SOURCE, revision=REVISION, local_files_only=True))
+    root = Path(__file__).parent
+    stage_dir = root / "build" / "hub-stage"
+    if stage_dir.exists():
+        shutil.rmtree(stage_dir)
+    stage_dir.mkdir(parents=True)
+    for name in REQUIRED:
+        shutil.copy2(root / name, stage_dir / name)
+    for name in TOKENIZER:
+        shutil.copy2(source / name, stage_dir / name)
+    shutil.copy2(root / "build/native-parity.json", stage_dir / "native-parity.json")
+    shutil.copy2(root / "build/coreml-parity-fp16.json", stage_dir / "coreml-parity-fp16.json")
+    shutil.copytree(root / "reports", stage_dir / "reports")
+    package = root / "build/JeffDecision-L128-FP16.mlpackage"
+    shutil.copytree(package, stage_dir / package.name)
+    w8_package = root / "build" / W8_PACKAGE
+    report = json.loads((root / "reports/w8-validation.json").read_text())
+    validate_w8_report(report)
+    if package_file_hashes(w8_package) != report["package_files_sha256"]:
+        raise ValueError("W8 package does not match the verified release report")
+    shutil.copytree(w8_package, stage_dir / W8_PACKAGE)
+    return stage_dir
+
+
+def main() -> None:
+    native = json.loads(Path("build/native-parity.json").read_text())
+    coreml = json.loads(Path("build/coreml-parity-fp16.json").read_text())
+    if len(native) != 4 or len(coreml) != 4 or not all(row["top_label_agreement"] for row in coreml):
+        raise RuntimeError("the four-case trained-model/Core ML parity evidence is incomplete")
+    if max(row["max_logit_error"] for row in coreml) > 0.25:
+        raise RuntimeError("Core ML parity exceeds the published tolerance")
+    stage_dir = stage()
+    api = HfApi()
+    api.create_repo(REPO_ID, repo_type="model", private=False, exist_ok=True)
+    result = api.upload_folder(
+        repo_id=REPO_ID,
+        repo_type="model",
+        folder_path=str(stage_dir),
+        commit_message="Publish validated Jeff GLiFormer Large L128 FP16 Core ML classifier",
+    )
+    print(result, flush=True)
+    print(json.dumps(api.list_repo_files(REPO_ID), indent=2), flush=True)
+
+
+if __name__ == "__main__":
+    main()

quantize.py

@@ -0,0 +1,63 @@
+"""Create targeted int8 Jeff Core ML variants without modifying the FP16 source."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import coremltools as ct
+import coremltools.optimize.coreml as cto
+
+
+def package_bytes(path: Path) -> int:
+    return sum(file.stat().st_size for file in path.rglob("*") if file.is_file())
+
+
+def selected_constants(model, scheme: str) -> list[str]:
+    metadata = cto.get_weights_metadata(model, weight_threshold=2048)
+    selected = []
+    for name, weight in metadata.items():
+        if not weight.child_ops:
+            continue
+        consumer = weight.child_ops[0].op_type
+        embedding = consumer == "gather" and len(weight.val.shape) == 2
+        linear = consumer == "linear" and len(weight.val.shape) == 2
+        if (scheme == "e8" and embedding) or (scheme == "w8" and (embedding or linear)):
+            selected.append(name)
+    if not selected:
+        raise ValueError(f"no eligible constants found for {scheme}")
+    return selected
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--source", type=Path, default=Path("build/JeffDecision-L128-FP16.mlpackage"))
+    parser.add_argument("--scheme", choices=("e8", "w8"), required=True)
+    parser.add_argument("--output", type=Path)
+    args = parser.parse_args()
+    output = args.output or Path(f"build/JeffDecision-L128-{args.scheme.upper()}.mlpackage")
+    if output.exists():
+        parser.error(f"output already exists: {output}")
+    model = ct.models.MLModel(str(args.source), compute_units=ct.ComputeUnit.CPU_ONLY)
+    names = selected_constants(model, args.scheme)
+    config = cto.OpLinearQuantizerConfig(mode="linear_symmetric", dtype="int8", granularity="per_channel")
+    compressed = cto.linear_quantize_weights(
+        model, cto.OptimizationConfig(op_name_configs={name: config for name in names})
+    )
+    compressed.user_defined_metadata["precision"] = args.scheme
+    compressed.save(str(output))
+    report = {
+        "source": str(args.source.resolve()),
+        "source_bytes": package_bytes(args.source),
+        "output": str(output.resolve()),
+        "output_bytes": package_bytes(output),
+        "compressed_constants": len(names),
+        "scheme": args.scheme,
+    }
+    Path(f"build/quantize-{args.scheme}.json").write_text(json.dumps(report, indent=2) + "\n")
+    print(json.dumps(report, indent=2), flush=True)
+
+
+if __name__ == "__main__":
+    main()

reports/w8-native.json

@@ -0,0 +1,77 @@
+[
+  {
+    "name": "billing",
+    "labels": [
+      "billing: invoice or payment issue",
+      "support: technical product issue"
+    ],
+    "native_logits": [
+      10.187458038330078,
+      -6.71131706237793
+    ],
+    "coreml_logits": [
+      10.1640625,
+      -6.76953125
+    ],
+    "max_logit_error": 0.05821418762207031,
+    "top_label_agreement": true,
+    "coreml_wall_ms": 591.8338329647668
+  },
+  {
+    "name": "technical",
+    "labels": [
+      "billing: invoice or payment issue",
+      "support: technical product issue"
+    ],
+    "native_logits": [
+      -12.322779655456543,
+      13.379047393798828
+    ],
+    "coreml_logits": [
+      -12.34375,
+      13.3125
+    ],
+    "max_logit_error": 0.06654739379882812,
+    "top_label_agreement": true,
+    "coreml_wall_ms": 18.682791967876256
+  },
+  {
+    "name": "three_way",
+    "labels": [
+      "schedule: appointment request",
+      "billing: payment issue",
+      "support: technical issue"
+    ],
+    "native_logits": [
+      5.41853141784668,
+      -12.076669692993164,
+      -9.080745697021484
+    ],
+    "coreml_logits": [
+      5.2890625,
+      -12.0,
+      -9.0234375
+    ],
+    "max_logit_error": 0.1294689178466797,
+    "top_label_agreement": true,
+    "coreml_wall_ms": 18.921707989647985
+  },
+  {
+    "name": "boolean",
+    "labels": [
+      "yes",
+      "no"
+    ],
+    "native_logits": [
+      1.0098832845687866,
+      -1.0589547157287598
+    ],
+    "coreml_logits": [
+      1.0498046875,
+      -1.123046875
+    ],
+    "max_logit_error": 0.06409215927124023,
+    "top_label_agreement": true,
+    "coreml_wall_ms": 9.147749980911613
+  }
+]

reports/w8-validation.json

@@ -0,0 +1,21 @@
+{
+  "source_revision": "d0a4e53d09cebe6bc963dd9be319d4279084bb2d",
+  "package": "JeffDecision-L128-W8.mlpackage",
+  "package_bytes": 488374793,
+  "fp16_package_bytes": 922812014,
+  "package_files_sha256": {
+    "Data/com.apple.CoreML/model.mlmodel": "7f6c1c290d3723229bf5e6c22f9fa9db187957f33ed72b3063ebbf88c8073e6f",
+    "Data/com.apple.CoreML/weights/weight.bin": "10bd21357d7313872abd964923b2483c817dddc66e0ea667d10c262dcc834aae",
+    "Manifest.json": "1744498652aebc3ab6068de32aefcf32bc46c4ab1faaba1bdd1a479c8ed94049"
+  },
+  "compressed_constants": 146,
+  "native_fixture_count": 4,
+  "native_choice_agreement": 4,
+  "max_logit_error": 0.1294689178466797,
+  "release_logit_error_gate": 0.25,
+  "automatic_full_request_p50_ms": 10.0669375,
+  "fp16_automatic_full_request_p50_ms": 10.119333,
+  "forced_cpu_ane_full_request_p50_ms": 19.097396,
+  "timing_scope": "exploratory local battery-powered real-request smoke test",
+  "scope": "Optional W8 size artifact verified on four native classification fixtures; no Decision Index or 2048 claim and no measured speed advantage."
+}