Publish GLiNER2.5 multilingual Core ML classification exports

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tokenizer/tokenizer.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,45 @@
+---
+license: apache-2.0
+library_name: coremltools
+pipeline_tag: text-classification
+tags:
+- coreml
+- gliner2
+- multilingual
+- apple-silicon
+---
+
+# GLiNER2.5 multilingual Core ML classification
+
+Core ML conversion of the classification path of
+[Fastino GLiNER2.5 multilingual](https://huggingface.co/fastino/gliner2.5-multi-v1),
+revision `a221b77a8baf4a613b8f8652661d41fa10a5641e` (Apache-2.0).
+The original checkpoint has 287,355,159 parameters. This export includes the
+encoder and trained classification head (278,719,489 parameters); it does not
+include entity, relation, record or span extraction. Use the original checkpoint
+for those tasks.
+
+The L128/K8 FP16 package is 576,528,829 bytes. It matched native choices on
+299 of 300 eligible fixed application requests, with one near tie reversing
+"sports" and "world news". Maximum chosen-confidence difference was 0.009249;
+median Python Core ML call was 8.81 ms on an M5 Pro running macOS 27.0.
+The FP32 reference package is 1,152,027,886 bytes; it matched all 100 sampled
+native choices, with maximum confidence difference 0.00000805 and median call
+11.24 ms. Four French, Spanish, Chinese and German smoke phrases gave the same
+chosen labels in native, FP16 and FP32. See the report JSON files. These are
+parity checks, not a complete Decision Index run or ANE-only timings.
+
+The model uses the upstream GLiNER2 schema and tokenizer supplied here.
+The Core ML minimum target is iOS 17/macOS 14. At most eight labels fit this
+bucket; inputs over capacity require a larger model bucket rather than
+truncation. The included runtime loads only Core ML and tokenizer files:
+
+```bash
+uv sync
+uv run python runtime.py --model-dir . --text '科学家发现了一颗新的行星。' \
+  --task topic --labels '["science","sports","politics"]' --precision fp16
+```
+
+Use `--precision fp32` when exact native decisions around narrow margins matter.
+The conversion scripts, pinned dependencies and asset hashes are included.
+Fluid Inference converted the model; Fastino authored the original checkpoint.

assets.lock.json

@@ -0,0 +1,26 @@
+{
+  "source": "fastino/gliner2.5-multi-v1",
+  "revision": "a221b77a8baf4a613b8f8652661d41fa10a5641e",
+  "files": {
+    "config.json": {
+      "size": 3151,
+      "sha256": "8b59a0f426a65859c89cd1ea850c3529c09aa3be3a6fafd8eddfdd17b1bf0146"
+    },
+    "encoder_config/config.json": {
+      "size": 857,
+      "sha256": "fa4f9ef2903b5369ab172333aae4574e6a476511d7465845cf59f8360ee18716"
+    },
+    "model.safetensors": {
+      "size": 1149461028,
+      "sha256": "c1ff4ec0bc00031c15530b8f3c33d3677f27949e6a0cb52e1247a6224b6c5395"
+    },
+    "tokenizer.json": {
+      "size": 16035853,
+      "sha256": "c62446df87ae18ec98b133f8f84fc449a07cc89bbf8ef192a4cb5f9c53777a7a"
+    },
+    "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-multi-v1",
+  "source_revision": "a221b77a8baf4a613b8f8652661d41fa10a5641e",
+  "package": "build/gliner2_multi_classification_fp32_L128_K8.mlpackage",
+  "package_bytes": 1152027886,
+  "native_total_parameters": 287355159,
+  "exported_parameters": 278719489,
+  "wrapper_max_logit_error": 0.0,
+  "coremltools": "9.0",
+  "torch": "2.7.0",
+  "cases": [
+    {
+      "text": "The rocket launched successfully.",
+      "native_label": "sports",
+      "coreml_label": "sports",
+      "native_confidence": 0.5060790777206421,
+      "coreml_confidence": 0.5060756206512451,
+      "absolute_confidence_error": 3.4570693969726562e-06
+    },
+    {
+      "text": "The team won the football championship.",
+      "native_label": "sports",
+      "coreml_label": "sports",
+      "native_confidence": 0.9999996423721313,
+      "coreml_confidence": 0.9999996423721313,
+      "absolute_confidence_error": 0.0
+    },
+    {
+      "text": "The budget was approved by parliament.",
+      "native_label": "politics",
+      "coreml_label": "politics",
+      "native_confidence": 0.9999977350234985,
+      "coreml_confidence": 0.9999977350234985,
+      "absolute_confidence_error": 0.0
+    }
+  ]
+}

convert-coreml.py

@@ -0,0 +1,131 @@
+"""Convert and verify the pinned GLiNER2.5-multi 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-multi-v1"
+MODEL_REVISION = "a221b77a8baf4a613b8f8652661d41fa10a5641e"
+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-multi 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_multi_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_multi_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:ddee410a764552de583f87c2fa383b327f962cd0a3a06129d25463e300df9ec4
+size 990100

gliner2_multi_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:519b9689dce771f7434aa12ec68ea3ceb47d9675888f54825c0dbf84aea0ac41
+size 575538112

gliner2_multi_classification_fp16_L128_K8.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "5189F522-6EF7-44F9-A58A-C2AE3A2607EE": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        },
+        "53AB227A-708E-47B2-A73B-1C4A0787D02E": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        }
+    },
+    "rootModelIdentifier": "5189F522-6EF7-44F9-A58A-C2AE3A2607EE"
+}

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

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

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

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

gliner2_multi_classification_fp32_L128_K8.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "6FD8F497-0DFB-47AC-A8DE-EFECB501243E": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        },
+        "DAB0BCC1-3F7E-4D48-836A-E64F9EAD6142": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        }
+    },
+    "rootModelIdentifier": "6FD8F497-0DFB-47AC-A8DE-EFECB501243E"
+}

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-multi-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,39 @@
+"""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, precision: str = "fp16"):
+    model_dir = Path(model_dir)
+    package = model_dir / f"gliner2_multi_classification_{precision}_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)
+    parser.add_argument("--precision", choices=["fp16", "fp32"], default="fp16")
+    args = parser.parse_args()
+    print(json.dumps(classify(args.model_dir, args.text, args.task, json.loads(args.labels),
+                              args.length, args.max_options, args.precision), indent=2))
+
+
+if __name__ == "__main__":
+    main()

tokenizer/tokenizer.json

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

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-fp16-application300.json

@@ -0,0 +1,28 @@
+{
+  "model": "fastino/gliner2.5-multi-v1",
+  "revision": "a221b77a8baf4a613b8f8652661d41fa10a5641e",
+  "package": "build/gliner2_multi_classification_fp16_L128_K8.mlpackage",
+  "selected_manifest": "first eligible rows in source suite order; no gold labels used",
+  "counts": {
+    "checked": 300,
+    "too_many_options": 300,
+    "too_long": 75,
+    "duplicate_labels": 0,
+    "mismatches": 1
+  },
+  "maximum_confidence_error": 0.00924915075302124,
+  "mean_confidence_error": 0.0009126420815785726,
+  "model_call_p50_ms": 8.808917016722262,
+  "model_call_p95_ms": 13.894708012230694,
+  "failures": [
+    {
+      "suite": "jev.ag_news",
+      "index": 100,
+      "native": {
+        "label": "sports",
+        "confidence": 0.4976130723953247
+      },
+      "coreml": "world news and international politics"
+    }
+  ]
+}

verify-fp32-application100.json

@@ -0,0 +1,18 @@
+{
+  "model": "fastino/gliner2.5-multi-v1",
+  "revision": "a221b77a8baf4a613b8f8652661d41fa10a5641e",
+  "package": "build/gliner2_multi_classification_fp32_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": 31,
+    "duplicate_labels": 0,
+    "mismatches": 0
+  },
+  "maximum_confidence_error": 8.046627044677734e-06,
+  "mean_confidence_error": 7.531046867370605e-07,
+  "model_call_p50_ms": 11.235417041461915,
+  "model_call_p95_ms": 19.665875006467104,
+  "failures": []
+}

verify-multilingual-fixtures.json

@@ -0,0 +1,62 @@
+[
+  {
+    "text": "La sélection a remporté le championnat de football.",
+    "native": {
+      "label": "sports",
+      "confidence": 0.9999890327453613
+    },
+    "fp16": {
+      "label": "sports",
+      "confidence": 0.9999892711639404
+    },
+    "fp32": {
+      "label": "sports",
+      "confidence": 0.9999890327453613
+    }
+  },
+  {
+    "text": "El parlamento aprobó el presupuesto.",
+    "native": {
+      "label": "politics",
+      "confidence": 0.9999994039535522
+    },
+    "fp16": {
+      "label": "politics",
+      "confidence": 0.9999994039535522
+    },
+    "fp32": {
+      "label": "politics",
+      "confidence": 0.9999994039535522
+    }
+  },
+  {
+    "text": "科学家发现了一颗新的行星。",
+    "native": {
+      "label": "science",
+      "confidence": 0.9999904632568359
+    },
+    "fp16": {
+      "label": "science",
+      "confidence": 0.9999902248382568
+    },
+    "fp32": {
+      "label": "science",
+      "confidence": 0.9999904632568359
+    }
+  },
+  {
+    "text": "Das Team gewann die Meisterschaft.",
+    "native": {
+      "label": "sports",
+      "confidence": 0.9999986886978149
+    },
+    "fp16": {
+      "label": "sports",
+      "confidence": 0.9999986886978149
+    },
+    "fp32": {
+      "label": "sports",
+      "confidence": 0.9999986886978149
+    }
+  }
+]

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-multi-v1"
+MODEL_REVISION = "a221b77a8baf4a613b8f8652661d41fa10a5641e"
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--package", default="build/gliner2_multi_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-multi-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()