Publish GLiNER2.5 small Core ML classification exports

README.md

@@ -0,0 +1,62 @@
+---
+license: apache-2.0
+library_name: coremltools
+pipeline_tag: text-classification
+tags:
+- coreml
+- gliner2
+- apple-silicon
+- neural-engine
+---
+
+# GLiNER2.5 small Core ML classification
+
+This is a Core ML conversion of the **classification decision path** of
+[Fastino's GLiNER2.5 small](https://huggingface.co/fastino/gliner2.5-small-v1),
+source revision `7e6f537f10337497069276892a5ef435028252ce`.
+The original model has 73,881,879 parameters and is licensed Apache-2.0.
+This export contains its encoder and trained classification head (70,944,385
+parameters); entity, relation, record, count and span extraction heads are **not**
+included. Use the original checkpoint for those tasks.
+
+The FP16 L128/K8 package occupies 151,542,752 bytes. It accepts up to eight
+classification labels, with native GLiNER2 schema rendering. The tokenizer
+files are included in this repository. The Core ML deployment target is iOS 17
+or macOS 14. `preprocessing.py` and `runtime.py` implement the request path
+without loading the original model weights at inference time.
+
+A Python example, from the directory containing this README:
+
+```bash
+uv sync
+uv run python runtime.py --model-dir . \
+  --text "The rocket launched successfully." \
+  --task topic --labels '["science","sports","politics"]'
+```
+
+The model returns a label, confidence and probabilities. Inputs that exceed the
+bucket capacity need a larger bucket; the runtime must not truncate them. The
+runtime requires macOS to execute Core ML prediction.
+
+## Validation
+
+On an Apple M5 Pro running macOS 27.0, the FP16 package matched the native
+classifier's chosen label on all 100 eligible requests selected in source order
+from a fixed application suite. The largest chosen-label confidence difference
+was 0.001723. Median Python `MLModel.predict` call time was 7.72 ms, including
+Python/Core ML dispatch; this is not an ANE-only measure. There were 300 rows
+with more than eight options and seven over-length rows before 100 eligible rows
+were collected. The smoke run does not establish a Decision Index score or
+broader application accuracy. `verify-application100.json` contains the exact
+counts and results.
+
+An experimental LUT8 per-tensor package occupies 76,211,068 bytes and matched
+all 100 chosen labels, but its largest confidence difference was 0.07859.
+It is not the recommended parity artifact. Grouped-channel LUT8 requires an
+iOS 18 or later Core ML target and has not yet been evaluated.
+
+Conversion source, pinned dependencies and verification scripts are included.
+The exporter freezes two static DeBERTa attention expressions and uses a finite
+FP16 mask sentinel; the real-model tests and native/Core ML checks guard this
+rewrite. Upstream authors receive credit for the original model; Fluid
+Inference performed this Core ML conversion.

assets.lock.json

@@ -0,0 +1,26 @@
+{
+  "source": "fastino/gliner2.5-small-v1",
+  "revision": "7e6f537f10337497069276892a5ef435028252ce",
+  "files": {
+    "config.json": {
+      "size": 3152,
+      "sha256": "0b7d9e1401ceeb83e992ec66d2f93bff7e5646428f1b4706ec527cf88f53578a"
+    },
+    "encoder_config/config.json": {
+      "size": 856,
+      "sha256": "db837d0dc587f5858687ef860c1f400de10f3c3e44f88daef8cbda80d74e4c9c"
+    },
+    "model.safetensors": {
+      "size": 295567700,
+      "sha256": "4ee982787ace270d4bf15dbcb28ced38e0aa201372347114ceedd6336055de2b"
+    },
+    "tokenizer.json": {
+      "size": 8341713,
+      "sha256": "cbc8ae6037812709c9c26f2a160f8dc48b0440bcb79c8141804259ae2d6adac3"
+    },
+    "tokenizer_config.json": {
+      "size": 645,
+      "sha256": "0bf3ea0873234bd9bfdd3853c440395009ac6365a925b91654daed5396d655e1"
+    }
+  }
+}

compress-coreml.py

@@ -0,0 +1,46 @@
+"""Palettize a verified GLiNER2 classification Core ML model."""
+import argparse
+import json
+import time
+from pathlib import Path
+
+import coremltools as ct
+from coremltools.optimize.coreml import OpPalettizerConfig, OptimizationConfig, palettize_weights
+
+
+def package_bytes(path):
+    return sum(item.stat().st_size for item in path.rglob("*") if item.is_file())
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source", required=True)
+    parser.add_argument("--output", required=True)
+    parser.add_argument("--bits", type=int, choices=[4, 6, 8], default=8)
+    parser.add_argument("--granularity", choices=["per_tensor", "per_grouped_channel"], default="per_tensor")
+    parser.add_argument("--group-size", type=int, default=32)
+    args = parser.parse_args()
+    start = time.perf_counter()
+    model = ct.models.MLModel(args.source, skip_model_load=True)
+    config = OptimizationConfig(global_config=OpPalettizerConfig(
+        mode="kmeans", nbits=args.bits, granularity=args.granularity,
+        group_size=args.group_size,
+        enable_per_channel_scale=args.granularity == "per_grouped_channel",
+        num_kmeans_workers=4,
+    ))
+    compressed = palettize_weights(model, config=config)
+    compressed.short_description = f"{model.short_description}; LUT{args.bits} weights"
+    compressed.author = model.author
+    compressed.license = model.license
+    compressed.user_defined_metadata.update(model.user_defined_metadata)
+    compressed.user_defined_metadata["weight_compression"] = f"LUT{args.bits} kmeans"
+    compressed.save(args.output)
+    report = {"source": args.source, "output": args.output, "granularity": args.granularity,
+              "source_bytes": package_bytes(Path(args.source)),
+              "output_bytes": package_bytes(Path(args.output)), "compression_seconds": time.perf_counter() - start}
+    Path(args.output).with_suffix(".json").write_text(json.dumps(report, indent=2) + "\n")
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()

conversion.json

@@ -0,0 +1,37 @@
+{
+  "source_model": "fastino/gliner2.5-small-v1",
+  "source_revision": "7e6f537f10337497069276892a5ef435028252ce",
+  "package": "build/gliner2_small_classification_fp16_L128_K8.mlpackage",
+  "package_bytes": 151542752,
+  "native_total_parameters": 73881879,
+  "exported_parameters": 70944385,
+  "wrapper_max_logit_error": 4.76837158203125e-07,
+  "coremltools": "9.0",
+  "torch": "2.7.0",
+  "cases": [
+    {
+      "text": "The rocket launched successfully.",
+      "native_label": "science",
+      "coreml_label": "science",
+      "native_confidence": 0.9989821314811707,
+      "coreml_confidence": 0.9989795088768005,
+      "absolute_confidence_error": 2.6226043701171875e-06
+    },
+    {
+      "text": "The team won the football championship.",
+      "native_label": "sports",
+      "coreml_label": "sports",
+      "native_confidence": 0.9999417066574097,
+      "coreml_confidence": 0.9999417066574097,
+      "absolute_confidence_error": 0.0
+    },
+    {
+      "text": "The budget was approved by parliament.",
+      "native_label": "politics",
+      "coreml_label": "politics",
+      "native_confidence": 0.9999653100967407,
+      "coreml_confidence": 0.9999654293060303,
+      "absolute_confidence_error": 1.1920928955078125e-07
+    }
+  ]
+}

convert-coreml.py

@@ -0,0 +1,131 @@
+"""Convert and verify the pinned GLiNER2.5-small classification decision path."""
+import argparse
+import json
+import math
+from pathlib import Path
+
+import coremltools as ct
+import numpy as np
+import torch
+from gliner2 import AutoExtractor
+from huggingface_hub import snapshot_download
+from transformers.models.deberta_v2 import modeling_deberta_v2
+
+from export_model import GLiNER2ClassificationExport, coreml_safe_attention_forward
+from preprocessing import native_batch, prepare_classification
+
+MODEL_ID = "fastino/gliner2.5-small-v1"
+MODEL_REVISION = "7e6f537f10337497069276892a5ef435028252ce"
+EXAMPLES = [
+    ("The rocket launched successfully.", "topic", ["science", "sports", "politics"]),
+    ("The team won the football championship.", "topic", ["science", "sports", "politics"]),
+    ("The budget was approved by parliament.", "topic", ["science", "sports", "politics"]),
+]
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output-dir", default="build")
+    parser.add_argument("--length", type=int, default=128)
+    parser.add_argument("--max-options", type=int, default=8)
+    parser.add_argument("--precision", choices=["fp16", "fp32"], default="fp16")
+    args = parser.parse_args()
+    torch.set_num_threads(4)
+    source = snapshot_download(
+        MODEL_ID, revision=MODEL_REVISION,
+        allow_patterns=[
+            "config.json", "encoder_config/*", "model.safetensors", "tokenizer.json", "tokenizer_config.json"
+        ],
+    )
+    native = AutoExtractor.from_pretrained(source, map_location="cpu").eval()
+    wrapper = GLiNER2ClassificationExport(native).eval()
+    text, task, labels = EXAMPLES[0]
+    arrays = prepare_classification(native, text, task, labels, args.length, args.max_options)
+    tensors = tuple(torch.from_numpy(value) for value in arrays.values())
+    with torch.no_grad():
+        batch = native_batch(native, text, task, labels, args.length)
+        core = native._encode_core(batch)
+        expected = native.classifier(core["cls_specs"][0][0]["choice_states"]).squeeze(-1)
+        actual = wrapper(*tensors)[0][0, : len(labels)]
+        wrapper_error = float((expected - actual).abs().max())
+    if wrapper_error > 1e-4:
+        raise RuntimeError(f"Wrapper/native logit mismatch: {wrapper_error}")
+    # The upstream scale is a constant for a fixed DeBERTa attention head width.
+    # Its traced int32 sqrt is rejected by Core ML; freeze the identical float32
+    # value while tracing, and restore the upstream implementation immediately.
+    original_scale = modeling_deberta_v2.scaled_size_sqrt
+    original_rpos = modeling_deberta_v2.build_rpos
+    original_attention = modeling_deberta_v2.DisentangledSelfAttention.forward
+
+    def static_scale(query_layer, scale_factor):
+        value = math.sqrt(float(query_layer.shape[-1] * scale_factor))
+        return torch.tensor(value, dtype=torch.float32, device=query_layer.device)
+
+    modeling_deberta_v2.scaled_size_sqrt = static_scale
+    # The encoder only uses self-attention: query and key sequence lengths are
+    # identical, so the scripted build_rpos returns relative_pos unchanged.
+    # Freeze that branch to avoid a Core ML conditional with mismatched ranks.
+    modeling_deberta_v2.build_rpos = lambda query, key, relative_pos, buckets, max_pos: relative_pos
+    modeling_deberta_v2.DisentangledSelfAttention.forward = coreml_safe_attention_forward
+    try:
+        with torch.no_grad():
+            frozen = wrapper(*tensors)[0][0, : len(labels)]
+            frozen_error = float((expected - frozen).abs().max())
+            if frozen_error > 1e-4:
+                raise RuntimeError(f"Frozen attention scale changed native logits: {frozen_error}")
+            traced = torch.jit.trace(wrapper, tensors, check_trace=False)
+    finally:
+        modeling_deberta_v2.scaled_size_sqrt = original_scale
+        modeling_deberta_v2.build_rpos = original_rpos
+        modeling_deberta_v2.DisentangledSelfAttention.forward = original_attention
+    converted = ct.convert(
+        traced, convert_to="mlprogram", minimum_deployment_target=ct.target.iOS17,
+        compute_precision=ct.precision.FLOAT16 if args.precision == "fp16" else ct.precision.FLOAT32,
+        compute_units=ct.ComputeUnit.CPU_ONLY,
+        inputs=[
+            ct.TensorType(name="input_ids", shape=(1, args.length), dtype=np.int32),
+            ct.TensorType(name="attention_mask", shape=(1, args.length), dtype=np.int32),
+            ct.TensorType(name="marker_indices", shape=(1, args.max_options), dtype=np.int32),
+            ct.TensorType(name="marker_mask", shape=(1, args.max_options), dtype=np.float32),
+        ],
+        outputs=[ct.TensorType(name="logits", dtype=np.float32), ct.TensorType(name="probabilities", dtype=np.float32)],
+    )
+    converted.short_description = "GLiNER2.5-small native schema classification path"
+    converted.author = "Fastino (original); Fluid Inference (Core ML conversion)"
+    converted.license = "Apache-2.0"
+    converted.user_defined_metadata.update({
+        "source_model": MODEL_ID, "source_revision": MODEL_REVISION,
+        "scope": "classification only; entity/relation/record extraction heads not exported",
+        "length": str(args.length), "max_options": str(args.max_options),
+    })
+    out = Path(args.output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    package = out / f"gliner2_small_classification_{args.precision}_L{args.length}_K{args.max_options}.mlpackage"
+    converted.save(str(package))
+    runtime = ct.models.MLModel(str(package), compute_units=ct.ComputeUnit.ALL)
+    cases = []
+    for text, task, labels in EXAMPLES:
+        arrays = prepare_classification(native, text, task, labels, args.length, args.max_options)
+        native_output = native.classify_text(text, {task: labels}, include_confidence=True, max_len=args.length)[task]
+        prediction = runtime.predict(arrays)
+        scores = np.asarray(prediction["probabilities"])[0, : len(labels)]
+        choice = labels[int(scores.argmax())]
+        if choice != native_output["label"]:
+            raise RuntimeError(f"Core ML/native choice mismatch: {choice} != {native_output['label']}")
+        cases.append({
+            "text": text, "native_label": native_output["label"], "coreml_label": choice,
+            "native_confidence": native_output["confidence"], "coreml_confidence": float(scores.max()),
+            "absolute_confidence_error": abs(float(scores.max()) - native_output["confidence"]),
+        })
+    report = {
+        "source_model": MODEL_ID, "source_revision": MODEL_REVISION, "package": str(package),
+        "package_bytes": sum(f.stat().st_size for f in package.rglob("*") if f.is_file()),
+        "native_total_parameters": sum(p.numel() for p in native.parameters()),
+        "exported_parameters": sum(p.numel() for p in wrapper.parameters()),
+        "wrapper_max_logit_error": wrapper_error, "coremltools": ct.__version__,
+        "torch": torch.__version__, "cases": cases,
+    }
+    (out / "conversion.json").write_text(json.dumps(report, indent=2) + "\n")
+    print(json.dumps(report, indent=2))
+
+if __name__ == "__main__":
+    main()

export_model.py

@@ -0,0 +1,47 @@
+"""Native GLiNER2 classification path with explicit marker routing."""
+import torch
+from torch import nn
+from transformers.models.deberta_v2 import modeling_deberta_v2
+
+
+def coreml_safe_attention_forward(
+    self, hidden_states, attention_mask, output_attentions=False,
+    query_states=None, relative_pos=None, rel_embeddings=None,
+):
+    """Native DeBERTa attention with a finite mask sentinel for FP16 Core ML."""
+    if query_states is None:
+        query_states = hidden_states
+    query = self.transpose_for_scores(self.query_proj(query_states), self.num_attention_heads)
+    key = self.transpose_for_scores(self.key_proj(hidden_states), self.num_attention_heads)
+    value = self.transpose_for_scores(self.value_proj(hidden_states), self.num_attention_heads)
+    factor = 1 + int("c2p" in self.pos_att_type) + int("p2c" in self.pos_att_type)
+    scale = modeling_deberta_v2.scaled_size_sqrt(query, factor)
+    scores = torch.bmm(query, key.transpose(-1, -2) / scale.to(dtype=query.dtype))
+    if self.relative_attention:
+        relative = self.disentangled_attention_bias(
+            query, key, relative_pos, self.pos_dropout(rel_embeddings), factor
+        )
+        scores = scores + relative
+    scores = scores.view(-1, self.num_attention_heads, scores.size(-2), scores.size(-1))
+    scores = scores.masked_fill(~attention_mask.bool(), -1e4)
+    probabilities = self.dropout(torch.softmax(scores, dim=-1))
+    context = torch.bmm(probabilities.view(-1, probabilities.size(-2), probabilities.size(-1)), value)
+    context = context.view(-1, self.num_attention_heads, context.size(-2), context.size(-1))
+    context = context.permute(0, 2, 1, 3).contiguous()
+    context = context.view(context.size()[:-2] + (-1,))
+    return (context, probabilities) if output_attentions else (context, None)
+
+class GLiNER2ClassificationExport(nn.Module):
+    def __init__(self, native: nn.Module):
+        super().__init__()
+        self.encoder = native.encoder
+        self.classifier = native.classifier
+        self.temperature = float(native.boundary_settings.classification_temperature)
+
+    def forward(self, input_ids, attention_mask, marker_indices, marker_mask):
+        hidden = self.encoder(input_ids=input_ids.long(), attention_mask=attention_mask.long()).last_hidden_state
+        indices = marker_indices.long().unsqueeze(-1).expand(-1, -1, hidden.shape[-1])
+        states = hidden.gather(1, indices)
+        logits = self.classifier(states).squeeze(-1) / self.temperature
+        logits = torch.where(marker_mask > 0.5, logits, torch.full_like(logits, -1e4))
+        return logits, torch.softmax(logits, dim=-1)

gliner2_small_classification_fp16_L128_K8.mlpackage/Data/com.apple.CoreML/model.mlmodel

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

gliner2_small_classification_fp16_L128_K8.mlpackage/Data/com.apple.CoreML/weights/weight.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91200fe39fdcabfc341288e560de9786df102ba519bcbcd3271320017abb2cd6
+size 150945472

gliner2_small_classification_fp16_L128_K8.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "0BDBE49B-B06F-49EC-8702-7009DEAF64A4": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        },
+        "FBBC8447-2EAA-4114-BB90-A1ED959442C0": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        }
+    },
+    "rootModelIdentifier": "FBBC8447-2EAA-4114-BB90-A1ED959442C0"
+}

gliner2_small_classification_lut8_L128_K8.mlpackage/Data/com.apple.CoreML/model.mlmodel

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

gliner2_small_classification_lut8_L128_K8.mlpackage/Data/com.apple.CoreML/weights/weight.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:361194f5c5f530fc0e6f20705f7340f5e1ad6c5a451b5d3fc4d46364a6abbe00
+size 75598528

gliner2_small_classification_lut8_L128_K8.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "1F7B203F-B038-49C4-9982-5CEBB5449266": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        },
+        "4CB15B68-E62E-4344-86BA-955F68BADB51": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        }
+    },
+    "rootModelIdentifier": "4CB15B68-E62E-4344-86BA-955F68BADB51"
+}

preprocessing.py

@@ -0,0 +1,43 @@
+"""Native GLiNER2 schema preprocessing for a fixed Core ML bucket."""
+import numpy as np
+from gliner2 import Schema
+from gliner2.models.base import load_extractor_tokenizer
+from gliner2.processor import SchemaTransformer
+from gliner2.training.trainer import ExtractorCollator
+
+
+def load_processor(tokenizer_dir: str):
+    """Load only the tokenizer and schema formatter needed by the Core ML model."""
+    return SchemaTransformer(tokenizer=load_extractor_tokenizer(tokenizer_dir), token_pooling="first")
+
+def native_batch(native, text: str, task: str, labels: list[str], length: int):
+    schema = Schema().classification(task, labels)
+    collator = ExtractorCollator(native.processor, is_training=False, max_len=length, architecture=native.architecture)
+    return collator([(text, schema.build())])
+
+def prepare_classification(native, text: str, task: str, labels: list[str], length: int, max_options: int):
+    return prepare_with_processor(native.processor, text, task, labels, length, max_options)
+
+
+def prepare_with_processor(processor, text: str, task: str, labels: list[str], length: int, max_options: int):
+    if not 1 <= len(labels) <= max_options:
+        raise ValueError(f"Expected 1..{max_options} labels, got {len(labels)}")
+    schema = Schema().classification(task, labels)
+    collator = ExtractorCollator(processor, is_training=False, max_len=length, architecture="boundary")
+    batch = collator([(text, schema.build())])
+    ids = batch.input_ids.numpy()
+    attention = batch.attention_mask.numpy()
+    indices = batch.cls_marker_indices.numpy()
+    mask = batch.cls_marker_mask.numpy()
+    if ids.shape[1] > length or indices.shape[1] != len(labels) or int(mask.sum()) != len(labels):
+        raise ValueError("Input exceeds bucket or classification markers were truncated")
+    ids = np.pad(ids, ((0, 0), (0, length - ids.shape[1])), constant_values=processor.tokenizer.pad_token_id)
+    attention = np.pad(attention, ((0, 0), (0, length - attention.shape[1])))
+    indices = np.pad(indices, ((0, 0), (0, max_options - indices.shape[1])))
+    mask = np.pad(mask, ((0, 0), (0, max_options - mask.shape[1])))
+    return {
+        "input_ids": ids.astype(np.int32),
+        "attention_mask": attention.astype(np.int32),
+        "marker_indices": indices.astype(np.int32),
+        "marker_mask": mask.astype(np.float32),
+    }

pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "gliner2-small-coreml"
+version = "0.1.0"
+description = "Pinned GLiNER 2.5 small decision classifier Core ML export"
+requires-python = ">=3.12,<3.13"
+dependencies = [
+    "coremltools==9.0",
+    "gliner2[local]==2.0.0",
+    "huggingface-hub>=0.34,<1",
+    "numpy<2.3",
+    "protobuf>=5,<7",
+    "sentencepiece>=0.2,<0.3",
+    "torch==2.7.0",
+    "transformers==4.57.6",
+]
+
+[dependency-groups]
+dev = ["pytest>=8.4", "ruff>=0.13"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]
+
+[tool.ruff]
+line-length = 120
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]

runtime.py

@@ -0,0 +1,37 @@
+"""Run a GLiNER2 Core ML classifier without loading the original model weights."""
+import argparse
+import json
+from pathlib import Path
+
+import coremltools as ct
+import numpy as np
+
+from preprocessing import load_processor, prepare_with_processor
+
+
+def classify(model_dir: str, text: str, task: str, labels: list[str], length: int = 128, max_options: int = 8):
+    model_dir = Path(model_dir)
+    package = model_dir / f"gliner2_small_classification_fp16_L{length}_K{max_options}.mlpackage"
+    processor = load_processor(str(model_dir / "tokenizer"))
+    arrays = prepare_with_processor(processor, text, task, labels, length, max_options)
+    model = ct.models.MLModel(str(package), compute_units=ct.ComputeUnit.ALL)
+    scores = np.asarray(model.predict(arrays)["probabilities"])[0, : len(labels)]
+    return {"label": labels[int(scores.argmax())], "confidence": float(scores.max()),
+            "probabilities": {label: float(score) for label, score in zip(labels, scores)}}
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-dir", required=True)
+    parser.add_argument("--text", required=True)
+    parser.add_argument("--task", default="decision")
+    parser.add_argument("--labels", required=True, help="JSON list of label strings")
+    parser.add_argument("--length", type=int, default=128)
+    parser.add_argument("--max-options", type=int, default=8)
+    args = parser.parse_args()
+    print(json.dumps(classify(args.model_dir, args.text, args.task, json.loads(args.labels),
+                              args.length, args.max_options), indent=2))
+
+
+if __name__ == "__main__":
+    main()

tokenizer/tokenizer_config.json

@@ -0,0 +1,31 @@
+{
+  "add_prefix_space": true,
+  "backend": "tokenizers",
+  "bos_token": "[CLS]",
+  "cls_token": "[CLS]",
+  "do_lower_case": false,
+  "eos_token": "[SEP]",
+  "extra_special_tokens": [
+    "[SEP_STRUCT]",
+    "[SEP_TEXT]",
+    "[P]",
+    "[C]",
+    "[E]",
+    "[R]",
+    "[L]",
+    "[EXAMPLE]",
+    "[OUTPUT]",
+    "[DESCRIPTION]"
+  ],
+  "is_local": true,
+  "local_files_only": false,
+  "mask_token": "[MASK]",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "split_by_punct": false,
+  "tokenizer_class": "DebertaV2Tokenizer",
+  "unk_id": 3,
+  "unk_token": "[UNK]",
+  "vocab_type": "spm"
+}

verify-application100.json

@@ -0,0 +1,18 @@
+{
+  "model": "fastino/gliner2.5-small-v1",
+  "revision": "7e6f537f10337497069276892a5ef435028252ce",
+  "package": "build/gliner2_small_classification_fp16_L128_K8.mlpackage",
+  "selected_manifest": "first eligible rows in source suite order; no gold labels used",
+  "counts": {
+    "checked": 100,
+    "too_many_options": 300,
+    "too_long": 7,
+    "duplicate_labels": 0,
+    "mismatches": 0
+  },
+  "maximum_confidence_error": 0.0017229318618774414,
+  "mean_confidence_error": 0.00020694971084594726,
+  "model_call_p50_ms": 7.718917040619999,
+  "model_call_p95_ms": 9.14695899700746,
+  "failures": []
+}

verify-lut8-application100.json

@@ -0,0 +1,18 @@
+{
+  "model": "fastino/gliner2.5-small-v1",
+  "revision": "7e6f537f10337497069276892a5ef435028252ce",
+  "package": "build/gliner2_small_classification_lut8_L128_K8.mlpackage",
+  "selected_manifest": "first eligible rows in source suite order; no gold labels used",
+  "counts": {
+    "checked": 100,
+    "too_many_options": 300,
+    "too_long": 7,
+    "duplicate_labels": 0,
+    "mismatches": 0
+  },
+  "maximum_confidence_error": 0.07858973741531372,
+  "mean_confidence_error": 0.004985119104385376,
+  "model_call_p50_ms": 7.664750039111823,
+  "model_call_p95_ms": 10.965458990540355,
+  "failures": []
+}

verify.py

@@ -0,0 +1,83 @@
+"""Compare the pinned GLiNER2 native classifier with its Core ML export."""
+import argparse
+import json
+import statistics
+import time
+from pathlib import Path
+
+import coremltools as ct
+import numpy as np
+import torch
+from gliner2 import AutoExtractor
+
+from preprocessing import prepare_classification
+
+MODEL_ID = "fastino/gliner2.5-small-v1"
+MODEL_REVISION = "7e6f537f10337497069276892a5ef435028252ce"
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--package", default="build/gliner2_small_classification_fp16_L128_K8.mlpackage")
+    parser.add_argument("--suite", required=True)
+    parser.add_argument("--limit", type=int, default=100)
+    parser.add_argument("--length", type=int, default=128)
+    parser.add_argument("--max-options", type=int, default=8)
+    parser.add_argument("--out", default="build/verify.json")
+    args = parser.parse_args()
+    torch.set_num_threads(4)
+    source = Path.home() / ".cache/huggingface/hub/models--fastino--gliner2.5-small-v1/snapshots" / MODEL_REVISION
+    native = AutoExtractor.from_pretrained(str(source), map_location="cpu").eval()
+    model = ct.models.MLModel(args.package, compute_units=ct.ComputeUnit.ALL)
+    counts = {"checked": 0, "too_many_options": 0, "too_long": 0, "duplicate_labels": 0, "mismatches": 0}
+    errors = []
+    latencies = []
+    failures = []
+    for line in Path(args.suite).open():
+        row = json.loads(line)
+        options = row.get("options") or []
+        if len(options) > args.max_options or not options:
+            counts["too_many_options"] += 1
+            continue
+        labels = [(description or key).strip() for key, description in options]
+        if len(set(labels)) != len(labels):
+            counts["duplicate_labels"] += 1
+            continue
+        text = row["state"]
+        task = "decision"
+        try:
+            arrays = prepare_classification(native, text, task, labels, args.length, args.max_options)
+        except ValueError:
+            counts["too_long"] += 1
+            continue
+        expected = native.classify_text(text, {task: labels}, include_confidence=True, max_len=args.length)[task]
+        start = time.perf_counter()
+        prediction = model.predict(arrays)
+        latencies.append((time.perf_counter() - start) * 1000)
+        probabilities = np.asarray(prediction["probabilities"])[0, : len(labels)]
+        chosen = labels[int(probabilities.argmax())]
+        error = abs(float(probabilities.max()) - float(expected["confidence"]))
+        errors.append(error)
+        counts["checked"] += 1
+        if chosen != expected["label"]:
+            counts["mismatches"] += 1
+            failures.append({"suite": row["suite"], "index": row["index"], "native": expected, "coreml": chosen})
+        if counts["checked"] >= args.limit:
+            break
+    result = {
+        "model": MODEL_ID, "revision": MODEL_REVISION, "package": args.package,
+        "selected_manifest": "first eligible rows in source suite order; no gold labels used",
+        "counts": counts, "maximum_confidence_error": max(errors, default=None),
+        "mean_confidence_error": statistics.mean(errors) if errors else None,
+        "model_call_p50_ms": statistics.median(latencies[1:]) if len(latencies) > 1 else None,
+        "model_call_p95_ms": sorted(latencies[1:])[int(0.95 * (len(latencies) - 1))] if len(latencies) > 1 else None,
+        "failures": failures[:20],
+    }
+    Path(args.out).parent.mkdir(parents=True, exist_ok=True)
+    Path(args.out).write_text(json.dumps(result, indent=2) + "\n")
+    print(json.dumps(result, indent=2))
+    if counts["checked"] == 0 or counts["mismatches"]:
+        raise SystemExit(1)
+
+if __name__ == "__main__":
+    main()