Add validated GLiNER2 extraction Core ML stages

FP32 full extraction stages with selected native parity; base also includes FP16 with documented confidence drift. Classification artifacts remain available.

README.md

@@ -1,40 +1,44 @@
 ---
 license: apache-2.0
 library_name: coremltools
-pipeline_tag: text-classification
+pipeline_tag: token-classification
 tags:
 - coreml
 - gliner2
 - apple-silicon
 ---
 
-# GLiNER2.5 base Core ML classification
+# GLiNER2.5 base for Core ML
 
-Core ML FP16 conversion of the classification decision path in
-[Fastino GLiNER2.5 base](https://huggingface.co/fastino/gliner2.5-base-v1),
-revision `1a8bc24e00dc7300b9017c81d63e3dcdabb26596`.
-The original has 193,581,591 parameters (Apache-2.0). This package includes
-its trained encoder and classification head (184,945,921 parameters); it does
-not export entity, relation, record or span extraction. Use the original
-checkpoint for those tasks.
+This repository contains fixed-shape Core ML exports of the trained classification and extraction paths from [Fastino/gliner2.5-base-v1](https://huggingface.co/fastino/gliner2.5-base-v1) at revision `1a8bc24e00dc7300b9017c81d63e3dcdabb26596`. The original Apache-2.0 checkpoint has 193,581,591 parameters. Fastino authored the source model; Fluid Inference converted it. The model packages include the learned encoder, classification, boundary, relation, explicit-span, and record heads. The Python runtime keeps the source GLiNER2 schema, candidate selection, and decoder semantics.
+
+## Extraction
+
+The FP32 extraction stage packages support entities, relations, entity attributes, enum choices, natural/latent/anchorless records, and schemas mixed with classification. In a small fixed manifest of real text and schema fixtures, FP32 matched the native structured output on **11/11** cases. The largest FP32 confidence difference was 0.00000114. The multilingual manifest includes Spanish, French, Chinese, and German text. These checks are selected parity fixtures, not a Decision Index score or a full dataset evaluation.
+
+FP16 result: 11/11 structures matched; the largest confidence difference was 0.1653 on a latent-record fixture. The base extraction FP16 packages are also included for speed sensitive applications; use FP32 when confidence values or latent-record decisions need closer native agreement.
 
-The L128/K8 package is 388,981,604 bytes, with up to eight labels. It targets
-iOS 17/macOS 14. Included tokenizer and `preprocessing.py` reproduce native
-schema rendering without loading the original PyTorch weights at runtime.
 
 ```bash
 uv sync
-uv run python runtime.py --model-dir . --text "The rocket launched successfully." \
-  --task topic --labels '["science","sports","politics"]'
+uv run python - <<'PYCODE'
+from gliner2 import Schema
+from extraction_runtime import CoreMLBoundaryExtractor
+
+model = CoreMLBoundaryExtractor('.', precision='fp32')
+schema = Schema().entities(['person', 'organization', 'location'])
+print(model.extract('Alice founded Acme in Toronto.', schema, include_spans=True))
+PYCODE
 ```
 
-On an M5 Pro (macOS 27.0), this FP16 artifact matched the native chosen label
-on 100 of 100 eligible requests from a fixed application suite; the largest
-chosen-label confidence difference was 0.002999. Median Python Core ML call
-time was 8.82 ms. The selected sample skipped 300 rows with more than eight
-options and seven over-length rows before collecting 100 eligible cases.
-This is a smoke parity check, not a full Decision Index score or an ANE-only
-latency measure. See `verify-application100.json` for details.
+The extraction bucket holds up to 128 combined subword tokens, 64 text words, 8 extraction queries, and 8 classification choices. Candidate, explicit span, relation pair, and record capacities are fixed in the package names. Requests beyond the bucket raise `ValueError`; they require a larger exported bucket. The runtime uses the original tokenizer files and `gliner2==2.0.0`, but loads no PyTorch model weights. Run `verify-full-extraction.py` with the pinned native checkpoint for the selected parity check.
+
+On an M5 Pro with macOS 27.0, FP32 end-to-end median 9.93 ms with All. FP16 median was 8.98 ms with All, 10.26 ms with CPU+Neural Engine, and 21.39 ms with CPU Only for a selected three-label entity request after 20 warmups and over 200 Python calls. Those are local end-to-end measurements for this shape, not ANE-only latency or a device-wide benchmark.
+
+The feature graph compute plan assigned 53.13% of operations to ANE and 46.87% to CPU under CPU+Neural Engine on this machine. Per-tensor LUT8 compression reduced the FP16 feature package from 391 MB to 196 MB, but only 10/11 selected structures matched, so that compressed package is omitted.
+
+## Classification
+
+The original L128/K8 classification packages remain available, with a separate `runtime.py` entry point. Up to eight labels fit that bucket. 100/100 selected choices matched in FP16. See the classification report JSONs for the exact selected samples and limits. The full checkpoint's task and dataset scores have not been reproduced here.
 
-The conversion scripts, pinned dependencies and asset hashes are included.
-Fluid Inference converted the model; Fastino authored the original checkpoint.
+The Core ML deployment target is iOS 17/macOS 14. Conversion scripts, pinned dependencies, asset hashes, and selected verification reports are included. The source revision is a current pinned snapshot; identity with the historical Decision Index evaluation checkpoint has not been established.

benchmark-extraction.py

@@ -0,0 +1,76 @@
+"""Selected fixed-bucket end-to-end Core ML extraction latency on this Mac."""
+
+import argparse
+import json
+import platform
+import statistics
+import time
+from pathlib import Path
+
+import coremltools as ct
+import psutil
+from gliner2 import Schema
+
+from extraction_runtime import CoreMLBoundaryExtractor
+
+UNITS = {
+    "cpu_only": ct.ComputeUnit.CPU_ONLY,
+    "cpu_and_gpu": ct.ComputeUnit.CPU_AND_GPU,
+    "cpu_and_neural_engine": ct.ComputeUnit.CPU_AND_NE,
+    "all": ct.ComputeUnit.ALL,
+}
+
+
+def percentile(values, fraction):
+    ordered = sorted(values)
+    return ordered[min(round(fraction * (len(ordered) - 1)), len(ordered) - 1)]
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-dir", required=True)
+    parser.add_argument("--precision", choices=["fp16", "fp32"], default="fp32")
+    parser.add_argument("--units", choices=list(UNITS), default="all")
+    parser.add_argument("--warmup", type=int, default=20)
+    parser.add_argument("--iterations", type=int, default=200)
+    args = parser.parse_args()
+    text = "Alice founded Acme in Toronto in 2020."
+    schema = Schema().entities(["person", "organization", "location"])
+    started = time.perf_counter()
+    runtime = CoreMLBoundaryExtractor(args.model_dir, precision=args.precision, compute_units=UNITS[args.units])
+    load_ms = (time.perf_counter() - started) * 1000
+    for _ in range(args.warmup):
+        runtime.extract(text, schema)
+    process = psutil.Process()
+    latencies = []
+    peak_rss = process.memory_info().rss
+    for _ in range(args.iterations):
+        start = time.perf_counter()
+        runtime.extract(text, schema)
+        latencies.append((time.perf_counter() - start) * 1000)
+        peak_rss = max(peak_rss, process.memory_info().rss)
+    report = {
+        "purpose": "selected end-to-end entity extraction latency, no benchmark scoring",
+        "fixture": text,
+        "shape": "L128/W64/Q8/C192",
+        "precision": args.precision,
+        "compute_units": args.units,
+        "warmup": args.warmup,
+        "iterations": args.iterations,
+        "load_ms": load_ms,
+        "p50_ms": statistics.median(latencies),
+        "p95_ms": percentile(latencies, 0.95),
+        "mean_ms": statistics.mean(latencies),
+        "peak_process_rss_bytes": peak_rss,
+        "macos": platform.mac_ver()[0],
+        "machine": platform.machine(),
+        "coremltools": ct.__version__,
+    }
+    folder = Path(args.model_dir)
+    path = folder / f"benchmark-{args.precision}-{args.units}.json"
+    path.write_text(json.dumps(report, indent=2) + "\n")
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()

config.json

@@ -0,0 +1,99 @@
+{
+  "architecture": "boundary",
+  "architecture_version": 1,
+  "architectures": [
+    "BoundaryExtractor"
+  ],
+  "attn_implementation": "sdpa",
+  "boundary_head": {
+    "abstention_loss_weight": 0.2,
+    "abstention_threshold": 0.5,
+    "adaptive_threshold": false,
+    "bidirectional_proposals": true,
+    "boundary_attention_heads": 4,
+    "boundary_attention_layers": 2,
+    "boundary_attention_window": 128,
+    "boundary_dim": 128,
+    "boundary_ffn_multiplier": 2.0,
+    "boundary_focal_clip": 0.05,
+    "boundary_focal_gamma_negative": 2.0,
+    "boundary_focal_gamma_positive": 0.0,
+    "boundary_marginal_loss": "asymmetric_focal",
+    "boundary_negative_weight": 0.5,
+    "boundary_refinement_layers": 1,
+    "boundary_top_k_alpha": 0.08,
+    "boundary_top_k_bucket": 8,
+    "boundary_top_k_max": 128,
+    "candidate_attention_heads": 4,
+    "candidate_attention_layers": 0,
+    "candidate_budget": 192,
+    "candidate_pool": "shared",
+    "classification_loss_weight": 1.0,
+    "classification_temperature": 1.0,
+    "consistency_loss_weight": 0.1,
+    "consistency_warmup_steps": 2000,
+    "content_dim": 64,
+    "content_soft_max_pool": false,
+    "count_loss_weight": 0.2,
+    "directional_relation_states": true,
+    "dropout": 0.1,
+    "enable_abstention": true,
+    "enable_count_head": true,
+    "enable_records": true,
+    "enable_relations": true,
+    "enable_rotary_endpoints": true,
+    "enable_span_content": true,
+    "end_block_size": 256,
+    "end_top_k": 24,
+    "endpoint_difference_features": true,
+    "ends_per_start": 12,
+    "export_mode": "auto",
+    "hard_negative_keep_all_when_absent": true,
+    "hard_negatives_per_positive": 20,
+    "loss_reduction": "sum",
+    "max_gold_per_query": 64,
+    "max_negative_queries_per_batch": 64,
+    "min_pool_per_query": 8,
+    "minimum_hard_negatives": 16,
+    "multihead_pair_compat_heads": 8,
+    "negative_query_ratio": 1.0,
+    "overlap_policy": "flat",
+    "pair_dim": 128,
+    "pair_temperature": 1.0,
+    "pool_boundary_top_k": 32,
+    "pool_size": 192,
+    "proposal_loss_weight": 0.3,
+    "query_attention_layers": 0,
+    "query_conditioned_inside_weight": true,
+    "record_anchor_proposal_threshold": 0.2,
+    "record_anchor_threshold": 0.5,
+    "record_dim": 128,
+    "record_field_threshold": 0.5,
+    "record_instance_queries": 32,
+    "record_loss_weight": 1.0,
+    "record_temperature": 1.0,
+    "relation_argument_proposal_threshold": 0.2,
+    "relation_biaffine_content": true,
+    "relation_heads_per_type": 32,
+    "relation_loss_weight": 1.0,
+    "relation_pair_cap": 64,
+    "relation_tails_per_type": 32,
+    "relation_temperature": 1.0,
+    "rerank_listwise_weight": 0.3,
+    "reranker_endpoint_compat": true,
+    "rotary_base": 10000.0,
+    "soft_iou_anneal_steps": 20000,
+    "soft_iou_aux_weight": 0.2,
+    "start_top_k": 24,
+    "starts_per_end": 12,
+    "training_candidate_budget": 192,
+    "use_inside_evidence": true,
+    "vectorized_pair_elements": 16777216
+  },
+  "config_version": 3,
+  "max_len": 4096,
+  "model_name": "microsoft/deberta-v3-base",
+  "model_type": "extractor",
+  "token_pooling": "first",
+  "transformers_version": "5.8.0"
+}

convert-explicit-coreml.py

@@ -0,0 +1,170 @@
+"""Export GLiNER2.5 base trained explicit-span scorer for attributes and enums."""
+
+import argparse
+import json
+from pathlib import Path
+
+import coremltools as ct
+import numpy as np
+import torch
+from gliner2 import AutoExtractor, Schema
+from huggingface_hub import snapshot_download
+
+from extraction_export import ExtractionExplicitSpanExport, ExtractionFeaturesExport, coreml_trace_patches
+from preprocessing import prepare_extraction
+
+MODEL_ID = "fastino/gliner2.5-base-v1"
+MODEL_REVISION = "1a8bc24e00dc7300b9017c81d63e3dcdabb26596"
+INPUT_NAMES = (
+    "text_states",
+    "text_mask",
+    "query_states",
+    "query_mask",
+    "boundary_states",
+    "start_logits",
+    "end_logits",
+    "inside_prefix",
+    "inside_prefix_mean",
+    "span_indices",
+    "span_mask",
+)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output-dir", default="build/extraction")
+    parser.add_argument("--precision", choices=["fp16", "fp32"], default="fp32")
+    parser.add_argument("--length", type=int, default=128)
+    parser.add_argument("--max-words", type=int, default=64)
+    parser.add_argument("--max-queries", type=int, default=8)
+    parser.add_argument("--max-spans", type=int, default=64)
+    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()
+    text = "Alice founded Acme in Toronto in 2020."
+    schema = Schema().entities(["person", "organization", "location"])
+    arrays, batch = prepare_extraction(native.processor, text, schema, args.length, args.max_words, args.max_queries)
+    tensors = tuple(torch.from_numpy(value) for value in arrays.values())
+    with torch.no_grad(), coreml_trace_patches():
+        features = ExtractionFeaturesExport(native).eval()(*tensors)
+    with torch.no_grad():
+        core = native._encode_core(batch)
+        candidates = native.boundary_head(
+            core["text_states"], core["text_mask"], core["query_states"], core["query_mask"]
+        ).candidates
+    query_count = core["query_states"].shape[1]
+    indices = torch.zeros(1, args.max_queries, args.max_spans, 2, dtype=torch.int32)
+    mask = torch.zeros(1, args.max_queries, args.max_spans, dtype=torch.float32)
+    count = min(args.max_spans, candidates.indices.shape[2])
+    indices[:, :query_count, :count] = candidates.indices[:, :query_count, :count].int()
+    mask[:, :query_count, :count] = candidates.valid_mask[:, :query_count, :count].float()
+    wrapper = ExtractionExplicitSpanExport(native).eval()
+    arguments = (
+        features[0],
+        tensors[3],
+        features[1],
+        tensors[5],
+        features[2],
+        features[4],
+        features[5],
+        features[6],
+        features[7],
+        indices,
+        mask,
+    )
+    with torch.no_grad():
+        reference = wrapper(*arguments)
+        native_reference = native.boundary_head.score_explicit_spans(
+            core["text_states"],
+            core["text_mask"],
+            core["query_states"],
+            core["query_mask"],
+            indices[:, :query_count].long(),
+            mask[:, :query_count].bool(),
+        )
+        wrapper_error = float(
+            (reference[:, :query_count][mask[:, :query_count].bool()] - native_reference[mask[:, :query_count].bool()])
+            .abs()
+            .max()
+        )
+        traced = torch.jit.trace(wrapper, arguments, check_trace=False)
+    if wrapper_error > 1e-4:
+        raise RuntimeError(f"Explicit span wrapper differs from native: {wrapper_error}")
+    precision = ct.precision.FLOAT16 if args.precision == "fp16" else ct.precision.FLOAT32
+    converted = ct.convert(
+        traced,
+        convert_to="mlprogram",
+        minimum_deployment_target=ct.target.iOS17,
+        compute_precision=precision,
+        compute_units=ct.ComputeUnit.CPU_ONLY,
+        inputs=[
+            ct.TensorType(name=name, shape=tuple(value.shape), dtype=np.int32 if name == "span_indices" else np.float32)
+            for name, value in zip(INPUT_NAMES, arguments)
+        ],
+        outputs=[ct.TensorType(name="span_logits", dtype=np.float32)],
+    )
+    converted.short_description = "GLiNER2.5 base trained explicit-span extraction scorer"
+    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,
+            "stage": "trained explicit-span proposal and reranker",
+            "word_capacity": str(args.max_words),
+            "query_capacity": str(args.max_queries),
+            "span_capacity": str(args.max_spans),
+        }
+    )
+    out = Path(args.output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    suffix = f"{args.precision}_W{args.max_words}_Q{args.max_queries}_S{args.max_spans}"
+    package = out / f"gliner2_base_explicit_{suffix}.mlpackage"
+    converted.save(str(package))
+    runtime = ct.models.MLModel(str(package), compute_units=ct.ComputeUnit.CPU_ONLY)
+    predicted = runtime.predict(
+        {
+            name: value.detach().numpy().astype(np.int32 if name == "span_indices" else np.float32)
+            for name, value in zip(INPUT_NAMES, arguments)
+        }
+    )["span_logits"]
+    runtime_error = float(
+        np.max(
+            np.abs(
+                predicted[:, :query_count][mask[:, :query_count].bool().numpy()]
+                - reference.numpy()[:, :query_count][mask[:, :query_count].bool().numpy()]
+            )
+        )
+    )
+    if not np.isfinite(runtime_error):
+        raise RuntimeError("Explicit-span scorer produced non-finite logits")
+    report = {
+        "source_model": MODEL_ID,
+        "source_revision": MODEL_REVISION,
+        "precision": args.precision,
+        "fixture": text,
+        "valid_spans": int(mask.sum()),
+        "wrapper_max_absolute_error": wrapper_error,
+        "coreml_max_absolute_error": runtime_error,
+        "package": str(package),
+        "package_bytes": sum(file.stat().st_size for file in package.rglob("*") if file.is_file()),
+        "coremltools": ct.__version__,
+        "torch": torch.__version__,
+    }
+    (out / f"explicit-{suffix}.json").write_text(json.dumps(report, indent=2) + "\n")
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()

convert-extraction-coreml.py

@@ -0,0 +1,217 @@
+"""Export the trained GLiNER2.5 base boundary extraction stages to Core ML."""
+
+import argparse
+import json
+import shutil
+from pathlib import Path
+
+import coremltools as ct
+import numpy as np
+import torch
+from gliner2 import AutoExtractor, Schema
+from huggingface_hub import snapshot_download
+
+from convert_extraction_names import FEATURE_NAMES, SCORE_INPUT_NAMES
+from extraction_export import ExtractionFeaturesExport, ExtractionScoreExport, coreml_trace_patches
+from extraction_pool import select_candidates
+from preprocessing import prepare_extraction
+
+MODEL_ID = "fastino/gliner2.5-base-v1"
+MODEL_REVISION = "1a8bc24e00dc7300b9017c81d63e3dcdabb26596"
+FIXTURE_TEXT = "Alice founded Acme in Toronto in 2020."
+FIXTURE_SCHEMA = Schema().entities(["person", "organization", "location"])
+
+
+def package_bytes(path: Path) -> int:
+    return sum(file.stat().st_size for file in path.rglob("*") if file.is_file())
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output-dir", default="build/extraction")
+    parser.add_argument("--length", type=int, default=128, help="Subword capacity")
+    parser.add_argument("--max-words", type=int, default=64)
+    parser.add_argument("--max-queries", type=int, default=8)
+    parser.add_argument("--precision", choices=["fp16", "fp32"], default="fp32")
+    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()
+    arrays, batch = prepare_extraction(
+        native.processor, FIXTURE_TEXT, FIXTURE_SCHEMA, args.length, args.max_words, args.max_queries
+    )
+    tensors = tuple(torch.from_numpy(value) for value in arrays.values())
+    features_wrapper = ExtractionFeaturesExport(native).eval()
+    with torch.no_grad(), coreml_trace_patches():
+        features_reference = features_wrapper(*tensors)
+        traced_features = torch.jit.trace(features_wrapper, tensors, check_trace=False)
+    with torch.no_grad():
+        native_core = native._encode_core(batch)
+        valid_words = native_core["text_states"].shape[1]
+        valid_queries = native_core["query_states"].shape[1]
+        routing_error = max(
+            float((features_reference[0][:, :valid_words] - native_core["text_states"]).abs().max()),
+            float((features_reference[1][:, :valid_queries] - native_core["query_states"]).abs().max()),
+        )
+    if routing_error > 1e-4:
+        raise RuntimeError(f"Traced routing differs from native: {routing_error}")
+
+    precision = ct.precision.FLOAT16 if args.precision == "fp16" else ct.precision.FLOAT32
+    input_names = tuple(arrays)
+    features_model = ct.convert(
+        traced_features,
+        convert_to="mlprogram",
+        minimum_deployment_target=ct.target.iOS17,
+        compute_precision=precision,
+        compute_units=ct.ComputeUnit.CPU_ONLY,
+        inputs=[ct.TensorType(name=name, shape=arrays[name].shape, dtype=arrays[name].dtype) for name in input_names],
+        outputs=[ct.TensorType(name=name, dtype=np.float32) for name in FEATURE_NAMES],
+    )
+    features_model.short_description = "GLiNER2.5 base trained boundary extraction features"
+    features_model.author = "Fastino (original); Fluid Inference (Core ML conversion)"
+    features_model.license = "Apache-2.0"
+    features_model.user_defined_metadata.update(
+        {
+            "source_model": MODEL_ID,
+            "source_revision": MODEL_REVISION,
+            "stage": "extraction features and trained boundary heads",
+            "subword_capacity": str(args.length),
+            "word_capacity": str(args.max_words),
+            "query_capacity": str(args.max_queries),
+        }
+    )
+    out = Path(args.output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(Path(source) / "config.json", out / "config.json")
+    tokenizer_dir = out / "tokenizer"
+    tokenizer_dir.mkdir(exist_ok=True)
+    for name in ("tokenizer.json", "tokenizer_config.json"):
+        shutil.copy2(Path(source) / name, tokenizer_dir / name)
+    suffix = f"{args.precision}_L{args.length}_W{args.max_words}_Q{args.max_queries}"
+    features_path = out / f"gliner2_base_extraction_features_{suffix}.mlpackage"
+    if features_path.exists():
+        shutil.rmtree(features_path)
+    features_model.save(str(features_path))
+    print(f"Saved {features_path}", flush=True)
+
+    head = native.boundary_head
+    pooled = select_candidates(
+        features_reference[8],
+        features_reference[9],
+        features_reference[3].bool(),
+        tensors[5].bool(),
+        features_reference[4],
+        features_reference[5],
+        boundary_top_k=head.shared_pool_builder.pool_boundary_top_k,
+        pool_size=head.shared_pool_builder.pool_size,
+        min_pool_per_query=head.shared_pool_builder.min_pool_per_query,
+    )
+    score_tensors = (
+        features_reference[0],
+        tensors[3],
+        features_reference[1],
+        tensors[5],
+        features_reference[2],
+        features_reference[4],
+        features_reference[5],
+        features_reference[6],
+        features_reference[7],
+        pooled.indices.int(),
+        pooled.mask.float(),
+        pooled.compat_logits,
+    )
+    scorer_wrapper = ExtractionScoreExport(native).eval()
+    with torch.no_grad():
+        scores_reference = scorer_wrapper(*score_tensors)
+        traced_scores = torch.jit.trace(scorer_wrapper, score_tensors, check_trace=False)
+    scorer_model = ct.convert(
+        traced_scores,
+        convert_to="mlprogram",
+        minimum_deployment_target=ct.target.iOS17,
+        compute_precision=precision,
+        compute_units=ct.ComputeUnit.CPU_ONLY,
+        inputs=[
+            ct.TensorType(
+                name=name, shape=tuple(value.shape), dtype=np.int32 if name == "candidate_indices" else np.float32
+            )
+            for name, value in zip(SCORE_INPUT_NAMES, score_tensors)
+        ],
+        outputs=[
+            ct.TensorType(name="pair_logits", dtype=np.float32),
+            ct.TensorType(name="candidate_states", dtype=np.float32),
+        ],
+    )
+    scorer_model.short_description = "GLiNER2.5 base trained shared-pool extraction scorer"
+    scorer_model.author = "Fastino (original); Fluid Inference (Core ML conversion)"
+    scorer_model.license = "Apache-2.0"
+    scorer_model.user_defined_metadata.update(
+        {
+            "source_model": MODEL_ID,
+            "source_revision": MODEL_REVISION,
+            "stage": "trained extraction candidate scorer",
+            "candidate_capacity": str(head.shared_pool_builder.pool_size),
+        }
+    )
+    scorer_path = out / f"gliner2_base_extraction_scorer_{suffix}.mlpackage"
+    if scorer_path.exists():
+        shutil.rmtree(scorer_path)
+    scorer_model.save(str(scorer_path))
+    print(f"Saved {scorer_path}", flush=True)
+
+    # The first runtime check uses the same selected real fixture as the trace.
+    runtime_features = ct.models.MLModel(str(features_path), compute_units=ct.ComputeUnit.CPU_ONLY)
+    predicted_features = runtime_features.predict(arrays)
+    errors = {
+        name: float(np.max(np.abs(np.asarray(predicted_features[name]) - reference.detach().numpy())))
+        for name, reference in zip(FEATURE_NAMES, features_reference)
+    }
+    if any(not np.isfinite(value) for value in errors.values()):
+        raise RuntimeError("Extraction features contain non-finite values")
+    runtime_scorer = ct.models.MLModel(str(scorer_path), compute_units=ct.ComputeUnit.CPU_ONLY)
+    score_arrays = {
+        name: value.detach().numpy().astype(np.int32 if name == "candidate_indices" else np.float32)
+        for name, value in zip(SCORE_INPUT_NAMES, score_tensors)
+    }
+    predicted_scores = runtime_scorer.predict(score_arrays)
+    errors["pair_logits"] = float(np.max(np.abs(predicted_scores["pair_logits"] - scores_reference[0].numpy())))
+    errors["candidate_states"] = float(
+        np.max(np.abs(predicted_scores["candidate_states"] - scores_reference[1].numpy()))
+    )
+    if any(not np.isfinite(value) for value in errors.values()):
+        raise RuntimeError("Extraction scorer contains non-finite values")
+    report = {
+        "source_model": MODEL_ID,
+        "source_revision": MODEL_REVISION,
+        "precision": args.precision,
+        "fixture": FIXTURE_TEXT,
+        "shape": {
+            "subwords": args.length,
+            "words": args.max_words,
+            "queries": args.max_queries,
+            "candidates": head.shared_pool_builder.pool_size,
+        },
+        "routing_max_absolute_error": routing_error,
+        "runtime_max_absolute_errors": errors,
+        "packages": {
+            "features": {"path": str(features_path), "bytes": package_bytes(features_path)},
+            "scorer": {"path": str(scorer_path), "bytes": package_bytes(scorer_path)},
+        },
+        "coremltools": ct.__version__,
+        "torch": torch.__version__,
+    }
+    (out / f"conversion-{suffix}.json").write_text(json.dumps(report, indent=2) + "\n")
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()

convert-record-coreml.py

@@ -0,0 +1,222 @@
+"""Export GLiNER2.5 base trained record assignment and anchorless heads."""
+
+import argparse
+import json
+import shutil
+from pathlib import Path
+
+import coremltools as ct
+import numpy as np
+import torch
+from gliner2 import AutoExtractor, Schema
+from gliner2.training.trainer import ExtractorCollator
+from huggingface_hub import snapshot_download
+
+from extraction_export import ExtractionRecordAnchorlessExport, ExtractionRecordAssignmentExport
+
+MODEL_ID = "fastino/gliner2.5-base-v1"
+MODEL_REVISION = "1a8bc24e00dc7300b9017c81d63e3dcdabb26596"
+FIXTURE_TEXT = "Alice works at Acme. Bob works at Beta."
+
+
+def record_fixture(native, mode):
+    schema = Schema()
+    builder = schema.structure("employment", mode=mode, anchor="person" if mode == "natural" else None)
+    builder.field("person", dtype="str")
+    builder.field("company", dtype="str")
+    batch = ExtractorCollator(native.processor, is_training=False, max_len=None, architecture="boundary")(
+        [(FIXTURE_TEXT, schema.build())]
+    )
+    with torch.no_grad():
+        core = native._encode_core(batch)
+        candidates = native.boundary_head(
+            core["text_states"], core["text_mask"], core["query_states"], core["query_mask"]
+        ).candidates
+        spec = next(iter(batch.record_specs[0].values()))
+        group = native.record_decoder.forward_group(spec, core["query_states"][0], candidates, 0)
+        field_states = [
+            candidates.candidate_states[0, query_id][candidates.valid_mask[0, query_id]]
+            for query_id in group.field_query_ids
+        ]
+        queries = core["query_states"][0][group.field_query_ids]
+    return group, spec, field_states, queries
+
+
+def pad_first(value, size: int):
+    if value.shape[0] > size:
+        raise ValueError(f"Real record fixture exceeds bucket capacity {size}")
+    result = value.new_zeros((size, *value.shape[1:]))
+    result[: value.shape[0]] = value
+    return result
+
+
+def package_bytes(path):
+    return sum(file.stat().st_size for file in path.rglob("*") if file.is_file())
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output-dir", default="build/extraction")
+    parser.add_argument("--precision", choices=["fp16", "fp32"], default="fp32")
+    parser.add_argument("--max-fields", type=int, default=8)
+    parser.add_argument("--max-candidates", type=int, default=192)
+    parser.add_argument("--max-instances", type=int, default=1536)
+    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()
+    head = native.record_decoder
+    if args.max_instances < args.max_fields * args.max_candidates:
+        raise ValueError("Instance bucket must hold all latent field candidates")
+
+    group, spec, field_states, queries = record_fixture(native, "natural")
+    anchor_index = group.field_query_ids.index(spec.anchor_query_id)
+    instances = field_states[anchor_index]
+    hidden = instances.shape[-1]
+    field_candidates = torch.zeros(args.max_fields, args.max_candidates, hidden)
+    for field_index, states in enumerate(field_states):
+        if states.shape[0] > args.max_candidates:
+            raise ValueError("Record candidate count exceeds bucket")
+        field_candidates[field_index, : states.shape[0]] = states
+    assignment_args = (pad_first(instances, args.max_instances), pad_first(queries, args.max_fields), field_candidates)
+    assignment_wrapper = ExtractionRecordAssignmentExport(native).eval()
+    with torch.no_grad():
+        assignment_reference = assignment_wrapper(*assignment_args)
+        for field_index, expected in enumerate(group.assign_logits):
+            actual = assignment_reference[0][: instances.shape[0], field_index, : expected.shape[1]]
+            if not torch.allclose(actual, expected, atol=1e-4):
+                raise RuntimeError("Record assignment wrapper differs from native")
+        assignment_trace = torch.jit.trace(assignment_wrapper, assignment_args, check_trace=False)
+
+    precision = ct.precision.FLOAT16 if args.precision == "fp16" else ct.precision.FLOAT32
+    assignment_model = ct.convert(
+        assignment_trace,
+        convert_to="mlprogram",
+        minimum_deployment_target=ct.target.iOS17,
+        compute_precision=precision,
+        compute_units=ct.ComputeUnit.CPU_ONLY,
+        inputs=[
+            ct.TensorType(name=name, shape=tuple(value.shape), dtype=np.float32)
+            for name, value in zip(("instance_states", "field_queries", "field_candidate_states"), assignment_args)
+        ],
+        outputs=[
+            ct.TensorType(name="assignment_logits", dtype=np.float32),
+            ct.TensorType(name="object_logits", dtype=np.float32),
+            ct.TensorType(name="latent_seed_logits", dtype=np.float32),
+        ],
+    )
+    assignment_model.short_description = "GLiNER2.5 base trained record assignment and object heads"
+    assignment_model.author = "Fastino (original); Fluid Inference (Core ML conversion)"
+    assignment_model.license = "Apache-2.0"
+    assignment_model.user_defined_metadata.update(
+        {
+            "source_model": MODEL_ID,
+            "source_revision": MODEL_REVISION,
+            "stage": "trained record assignment, object and latent seed heads",
+            "field_capacity": str(args.max_fields),
+            "candidate_capacity": str(args.max_candidates),
+            "instance_capacity": str(args.max_instances),
+        }
+    )
+    out = Path(args.output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    suffix = f"{args.precision}_F{args.max_fields}_C{args.max_candidates}_I{args.max_instances}"
+    assignment_path = out / f"gliner2_base_record_assignment_{suffix}.mlpackage"
+    if assignment_path.exists():
+        shutil.rmtree(assignment_path)
+    assignment_model.save(str(assignment_path))
+    assignment_runtime = ct.models.MLModel(str(assignment_path), compute_units=ct.ComputeUnit.CPU_ONLY)
+    assignment_prediction = assignment_runtime.predict(
+        {
+            name: value.numpy().astype(np.float32)
+            for name, value in zip(("instance_states", "field_queries", "field_candidate_states"), assignment_args)
+        }
+    )
+    assignment_errors = {
+        name: float(np.max(np.abs(assignment_prediction[name] - expected.numpy())))
+        for name, expected in zip(("assignment_logits", "object_logits", "latent_seed_logits"), assignment_reference)
+    }
+
+    _, _, anchorless_field_states, _ = record_fixture(native, "anchorless")
+    context = torch.cat(anchorless_field_states, 0)
+    context_size = args.max_fields * args.max_candidates
+    context_states = pad_first(context, context_size)
+    context_mask = torch.zeros(context_size, dtype=torch.float32)
+    context_mask[: context.shape[0]] = 1.0
+    anchorless_wrapper = ExtractionRecordAnchorlessExport(native).eval()
+    with torch.no_grad():
+        anchorless_reference = anchorless_wrapper(context_states, context_mask)
+        native_states = head._anchorless_states(anchorless_field_states)
+        wrapper_error = float((anchorless_reference - native_states).abs().max())
+        if wrapper_error > 1e-4:
+            raise RuntimeError(f"Anchorless wrapper differs from native: {wrapper_error}")
+        anchorless_trace = torch.jit.trace(anchorless_wrapper, (context_states, context_mask), check_trace=False)
+    anchorless_model = ct.convert(
+        anchorless_trace,
+        convert_to="mlprogram",
+        minimum_deployment_target=ct.target.iOS17,
+        compute_precision=precision,
+        compute_units=ct.ComputeUnit.CPU_ONLY,
+        inputs=[
+            ct.TensorType(name="context_states", shape=tuple(context_states.shape), dtype=np.float32),
+            ct.TensorType(name="context_mask", shape=tuple(context_mask.shape), dtype=np.float32),
+        ],
+        outputs=[ct.TensorType(name="instance_states", dtype=np.float32)],
+    )
+    anchorless_model.short_description = "GLiNER2.5 base trained anchorless record instance head"
+    anchorless_model.author = "Fastino (original); Fluid Inference (Core ML conversion)"
+    anchorless_model.license = "Apache-2.0"
+    anchorless_model.user_defined_metadata.update(
+        {
+            "source_model": MODEL_ID,
+            "source_revision": MODEL_REVISION,
+            "stage": "trained anchorless record instance head",
+            "context_capacity": str(context_size),
+        }
+    )
+    anchorless_path = out / f"gliner2_base_record_anchorless_{suffix}.mlpackage"
+    if anchorless_path.exists():
+        shutil.rmtree(anchorless_path)
+    anchorless_model.save(str(anchorless_path))
+    anchorless_runtime = ct.models.MLModel(str(anchorless_path), compute_units=ct.ComputeUnit.CPU_ONLY)
+    anchorless_prediction = anchorless_runtime.predict(
+        {
+            "context_states": context_states.numpy().astype(np.float32),
+            "context_mask": context_mask.numpy().astype(np.float32),
+        }
+    )["instance_states"]
+    anchorless_error = float(np.max(np.abs(anchorless_prediction - anchorless_reference.numpy())))
+    if not all(np.isfinite(value) for value in (*assignment_errors.values(), anchorless_error)):
+        raise RuntimeError("Record head produced non-finite values")
+    report = {
+        "source_model": MODEL_ID,
+        "source_revision": MODEL_REVISION,
+        "precision": args.precision,
+        "fixture": FIXTURE_TEXT,
+        "shape": {"fields": args.max_fields, "candidates": args.max_candidates, "instances": args.max_instances},
+        "assignment_max_absolute_errors": assignment_errors,
+        "anchorless_wrapper_max_absolute_error": wrapper_error,
+        "anchorless_coreml_max_absolute_error": anchorless_error,
+        "packages": {
+            "assignment": {"path": str(assignment_path), "bytes": package_bytes(assignment_path)},
+            "anchorless": {"path": str(anchorless_path), "bytes": package_bytes(anchorless_path)},
+        },
+        "coremltools": ct.__version__,
+        "torch": torch.__version__,
+    }
+    (out / f"record-{suffix}.json").write_text(json.dumps(report, indent=2) + "\n")
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()

convert-relation-coreml.py

@@ -0,0 +1,165 @@
+"""Export the trained GLiNER2.5 base sparse relation scorer to Core ML."""
+
+import argparse
+import json
+from pathlib import Path
+
+import coremltools as ct
+import numpy as np
+import torch
+from gliner2 import AutoExtractor, Schema
+from gliner2.models.base import QueryLayout
+from gliner2.training.trainer import ExtractorCollator
+from huggingface_hub import snapshot_download
+
+from extraction_export import ExtractionRelationExport
+
+MODEL_ID = "fastino/gliner2.5-base-v1"
+MODEL_REVISION = "1a8bc24e00dc7300b9017c81d63e3dcdabb26596"
+INPUT_NAMES = (
+    "text_states",
+    "text_length",
+    "relation_states",
+    "batch_index",
+    "relation_index",
+    "head_start",
+    "head_end",
+    "tail_start",
+    "tail_end",
+    "pair_mask",
+)
+
+
+def pad(value, size: int, fill=0):
+    if value.shape[0] > size:
+        raise ValueError(f"Relation fixture exceeds capacity {size}")
+    output = value.new_full((size, *value.shape[1:]), fill)
+    output[: value.shape[0]] = value
+    return output
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output-dir", default="build/extraction")
+    parser.add_argument("--precision", choices=["fp16", "fp32"], default="fp32")
+    parser.add_argument("--max-words", type=int, default=64)
+    parser.add_argument("--max-relations", type=int, default=4)
+    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()
+    text = "Alice founded Acme in Toronto."
+    schema = Schema().relations(["founded"])
+    batch = ExtractorCollator(native.processor, is_training=False, max_len=None, architecture="boundary")(
+        [(text, schema.build())]
+    )
+    with torch.no_grad():
+        core = native._encode_core(batch)
+        output = native.boundary_head(core["text_states"], core["text_mask"], core["query_states"], core["query_mask"])
+        sample = native._single_sample_candidates(output.candidates, 0)
+        relation_specs = core["rel_specs"][0]
+        pairs = native.relation_pair_generator.generate_batched(
+            sample, [QueryLayout(queries=())], [[entry["spec"] for entry in relation_specs]], compact=False
+        )
+        relation_states = torch.stack([entry["query_state"] for entry in relation_specs]).unsqueeze(0)
+        native_scores = native.relation_scorer(core["text_states"], relation_states, sample, pairs)
+    pair_cap = args.max_relations * native.boundary_settings.relation_pair_cap
+    text_states = torch.zeros(1, args.max_words, core["text_states"].shape[-1])
+    text_states[:, : core["text_states"].shape[1]] = core["text_states"]
+    relation_padded = torch.zeros(1, args.max_relations, relation_states.shape[-1])
+    relation_padded[:, : relation_states.shape[1]] = relation_states
+    arguments = (
+        text_states,
+        torch.tensor([core["text_states"].shape[1]], dtype=torch.int32),
+        relation_padded,
+        pad(pairs.batch_index.int(), pair_cap),
+        pad(pairs.relation_index.int(), pair_cap),
+        pad(pairs.head_start.int(), pair_cap),
+        pad(pairs.head_end.int(), pair_cap),
+        pad(pairs.tail_start.int(), pair_cap),
+        pad(pairs.tail_end.int(), pair_cap),
+        pad(pairs.pair_mask.float(), pair_cap),
+    )
+    wrapper = ExtractionRelationExport(native).eval()
+    with torch.no_grad():
+        reference = wrapper(*arguments)
+        wrapper_error = float((reference[: len(pairs)] - native_scores).abs().max())
+        traced = torch.jit.trace(wrapper, arguments, check_trace=False)
+    if wrapper_error > 1e-4:
+        raise RuntimeError(f"Relation wrapper differs from native: {wrapper_error}")
+    precision = ct.precision.FLOAT16 if args.precision == "fp16" else ct.precision.FLOAT32
+    converted = ct.convert(
+        traced,
+        convert_to="mlprogram",
+        minimum_deployment_target=ct.target.iOS17,
+        compute_precision=precision,
+        compute_units=ct.ComputeUnit.CPU_ONLY,
+        inputs=[
+            ct.TensorType(
+                name=name,
+                shape=tuple(value.shape),
+                dtype=np.float32 if name in ("text_states", "relation_states", "pair_mask") else np.int32,
+            )
+            for name, value in zip(INPUT_NAMES, arguments)
+        ],
+        outputs=[ct.TensorType(name="relation_logits", dtype=np.float32)],
+    )
+    converted.short_description = "GLiNER2.5 base trained sparse relation scoring head"
+    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,
+            "stage": "trained relation scorer",
+            "word_capacity": str(args.max_words),
+            "relation_capacity": str(args.max_relations),
+            "pair_capacity": str(pair_cap),
+        }
+    )
+    out = Path(args.output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    suffix = f"{args.precision}_W{args.max_words}_R{args.max_relations}_P{pair_cap}"
+    package = out / f"gliner2_base_relation_{suffix}.mlpackage"
+    converted.save(str(package))
+    model = ct.models.MLModel(str(package), compute_units=ct.ComputeUnit.CPU_ONLY)
+    prediction = model.predict(
+        {
+            name: value.numpy().astype(
+                np.float32 if name in ("text_states", "relation_states", "pair_mask") else np.int32
+            )
+            for name, value in zip(INPUT_NAMES, arguments)
+        }
+    )["relation_logits"]
+    runtime_error = float(np.max(np.abs(prediction[: len(pairs)] - reference.numpy()[: len(pairs)])))
+    if not np.isfinite(runtime_error):
+        raise RuntimeError("Relation scorer produced non-finite values")
+    report = {
+        "source_model": MODEL_ID,
+        "source_revision": MODEL_REVISION,
+        "precision": args.precision,
+        "fixture": text,
+        "valid_pairs": int(pairs.pair_mask.sum()),
+        "wrapper_max_absolute_error": wrapper_error,
+        "coreml_max_absolute_error": runtime_error,
+        "package": str(package),
+        "package_bytes": sum(file.stat().st_size for file in package.rglob("*") if file.is_file()),
+        "coremltools": ct.__version__,
+        "torch": torch.__version__,
+    }
+    (out / f"relation-{suffix}.json").write_text(json.dumps(report, indent=2) + "\n")
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()

convert_extraction_names.py

@@ -0,0 +1,31 @@
+"""Ordered tensor contract shared by extraction conversion and verification."""
+
+FEATURE_NAMES = (
+    "text_states",
+    "query_states",
+    "boundary_states",
+    "boundary_mask",
+    "start_logits",
+    "end_logits",
+    "inside_prefix",
+    "inside_prefix_mean",
+    "pool_start_projection",
+    "pool_end_projection",
+    "null_logits",
+    "count_log_rates",
+    "classification_logits",
+)
+SCORE_INPUT_NAMES = (
+    "text_states",
+    "text_mask",
+    "query_states",
+    "query_mask",
+    "boundary_states",
+    "start_logits",
+    "end_logits",
+    "inside_prefix",
+    "inside_prefix_mean",
+    "candidate_indices",
+    "candidate_mask",
+    "candidate_compatibility",
+)

extraction-assets.lock.json

@@ -0,0 +1,275 @@
+{
+  "source_model": "fastino/gliner2.5-base-v1",
+  "source_revision": "1a8bc24e00dc7300b9017c81d63e3dcdabb26596",
+  "package_files": [
+    {
+      "package": "gliner2_base_explicit_fp16_W64_Q8_S64.mlpackage",
+      "bytes": 614010,
+      "files": [
+        {
+          "path": "gliner2_base_explicit_fp16_W64_Q8_S64.mlpackage/Data/com.apple.CoreML/model.mlmodel",
+          "bytes": 61009,
+          "sha256": "833cfc75c7b45d95f423b00770569ad00707aad4d7e993d9288aacd6392901be"
+        },
+        {
+          "path": "gliner2_base_explicit_fp16_W64_Q8_S64.mlpackage/Data/com.apple.CoreML/weights/weight.bin",
+          "bytes": 552384,
+          "sha256": "b8f472bf52874cf6fbe92e08333cb1976236fe179a186efeba049f1814ca2f6f"
+        },
+        {
+          "path": "gliner2_base_explicit_fp16_W64_Q8_S64.mlpackage/Manifest.json",
+          "bytes": 617,
+          "sha256": "2f83e83160221b29ce2f9156518bfa6bdaefd94c7c1eabff8de06131374b41d6"
+        }
+      ]
+    },
+    {
+      "package": "gliner2_base_explicit_fp32_W64_Q8_S64.mlpackage",
+      "bytes": 1152468,
+      "files": [
+        {
+          "path": "gliner2_base_explicit_fp32_W64_Q8_S64.mlpackage/Data/com.apple.CoreML/model.mlmodel",
+          "bytes": 48811,
+          "sha256": "6226a1f7b91ceb1b2528d5eac17fa7b30db7c6e921ebc4a8b1b7ad4b8dca9096"
+        },
+        {
+          "path": "gliner2_base_explicit_fp32_W64_Q8_S64.mlpackage/Data/com.apple.CoreML/weights/weight.bin",
+          "bytes": 1103040,
+          "sha256": "7dded10597f6d93d30f9842d963e6a1ed503a7e1ed53d6f713ee22da38101e1f"
+        },
+        {
+          "path": "gliner2_base_explicit_fp32_W64_Q8_S64.mlpackage/Manifest.json",
+          "bytes": 617,
+          "sha256": "18d42e32e177e558362500e951fdde1310afce5a11435e7a108264c184e42d54"
+        }
+      ]
+    },
+    {
+      "package": "gliner2_base_extraction_features_fp16_L128_W64_Q8.mlpackage",
+      "bytes": 390998448,
+      "files": [
+        {
+          "path": "gliner2_base_extraction_features_fp16_L128_W64_Q8.mlpackage/Data/com.apple.CoreML/model.mlmodel",
+          "bytes": 1046087,
+          "sha256": "81a989bd9c9791ca2cb2b10c9456795a3f98cb2a41132ad894ec6aae3bee8c58"
+        },
+        {
+          "path": "gliner2_base_extraction_features_fp16_L128_W64_Q8.mlpackage/Data/com.apple.CoreML/weights/weight.bin",
+          "bytes": 389951744,
+          "sha256": "f89a14b93e79bc0c5f03ae1d2afdecabc12d0ba0a6551107efb60d19e2fef913"
+        },
+        {
+          "path": "gliner2_base_extraction_features_fp16_L128_W64_Q8.mlpackage/Manifest.json",
+          "bytes": 617,
+          "sha256": "5b86a3a9736fb9849f4cf6bcae5fd8038332c2ac4106f5ed5fc23a72c4b77ed4"
+        }
+      ]
+    },
+    {
+      "package": "gliner2_base_extraction_features_fp32_L128_W64_Q8.mlpackage",
+      "bytes": 780899033,
+      "files": [
+        {
+          "path": "gliner2_base_extraction_features_fp32_L128_W64_Q8.mlpackage/Data/com.apple.CoreML/model.mlmodel",
+          "bytes": 1012396,
+          "sha256": "952aba39fb31af06ae240e1c03ce0a9fe065c2e5997d4f455fb0df2055059103"
+        },
+        {
+          "path": "gliner2_base_extraction_features_fp32_L128_W64_Q8.mlpackage/Data/com.apple.CoreML/weights/weight.bin",
+          "bytes": 779886020,
+          "sha256": "3edc72e18c141125c4231b7a3b0d7d0105135271f7deff924818951e6f354ef0"
+        },
+        {
+          "path": "gliner2_base_extraction_features_fp32_L128_W64_Q8.mlpackage/Manifest.json",
+          "bytes": 617,
+          "sha256": "5d9751b4961ccdb017b0e8a01e73920ced48c101a9845164a19741802dc43f8c"
+        }
+      ]
+    },
+    {
+      "package": "gliner2_base_extraction_scorer_fp16_L128_W64_Q8.mlpackage",
+      "bytes": 903154,
+      "files": [
+        {
+          "path": "gliner2_base_extraction_scorer_fp16_L128_W64_Q8.mlpackage/Data/com.apple.CoreML/model.mlmodel",
+          "bytes": 42953,
+          "sha256": "a28d35b1697ca5877e4c37be3fc73636a6795c7a7fb589aadee053ecbc06d496"
+        },
+        {
+          "path": "gliner2_base_extraction_scorer_fp16_L128_W64_Q8.mlpackage/Data/com.apple.CoreML/weights/weight.bin",
+          "bytes": 859584,
+          "sha256": "63e7a5f12ea123730faf9248e3d5245d8861cda7bdc678a29b6ed10c1c0450a3"
+        },
+        {
+          "path": "gliner2_base_extraction_scorer_fp16_L128_W64_Q8.mlpackage/Manifest.json",
+          "bytes": 617,
+          "sha256": "25563e15f2ec7a511142b626c74007b9816de4fd3729395c2a40ca6da5e6a866"
+        }
+      ]
+    },
+    {
+      "package": "gliner2_base_extraction_scorer_fp32_L128_W64_Q8.mlpackage",
+      "bytes": 1750631,
+      "files": [
+        {
+          "path": "gliner2_base_extraction_scorer_fp32_L128_W64_Q8.mlpackage/Data/com.apple.CoreML/model.mlmodel",
+          "bytes": 32574,
+          "sha256": "dc02f86228a4c95872de1d6dab5d5a1ca2d89c464ba1df0eb1f4333cc4f517f9"
+        },
+        {
+          "path": "gliner2_base_extraction_scorer_fp32_L128_W64_Q8.mlpackage/Data/com.apple.CoreML/weights/weight.bin",
+          "bytes": 1717440,
+          "sha256": "ab96965841dd7802bb22d3a4d65ac2ef27e4df4daf4be1a49a65d8bc3c87f595"
+        },
+        {
+          "path": "gliner2_base_extraction_scorer_fp32_L128_W64_Q8.mlpackage/Manifest.json",
+          "bytes": 617,
+          "sha256": "753acbe0781d89b5b157da08ce5d75d21f61b0c4f86a9ceafa21d3274df54259"
+        }
+      ]
+    },
+    {
+      "package": "gliner2_base_record_anchorless_fp16_F8_C192_I1536.mlpackage",
+      "bytes": 1443015,
+      "files": [
+        {
+          "path": "gliner2_base_record_anchorless_fp16_F8_C192_I1536.mlpackage/Data/com.apple.CoreML/model.mlmodel",
+          "bytes": 6558,
+          "sha256": "3ae7e7e6540577572bc1ae82d334d9294dd2bfb2d270cdf5166edcb9ce487495"
+        },
+        {
+          "path": "gliner2_base_record_anchorless_fp16_F8_C192_I1536.mlpackage/Data/com.apple.CoreML/weights/weight.bin",
+          "bytes": 1435840,
+          "sha256": "73f5d6812653173c71dcd666e9477dc275fae42290bb0bfa5aef00e1c721a7f5"
+        },
+        {
+          "path": "gliner2_base_record_anchorless_fp16_F8_C192_I1536.mlpackage/Manifest.json",
+          "bytes": 617,
+          "sha256": "4b6d679bf502518e30cdc5e5a65154a6c37552937301ba9146c4a2057d13f7dd"
+        }
+      ]
+    },
+    {
+      "package": "gliner2_base_record_anchorless_fp32_F8_C192_I1536.mlpackage",
+      "bytes": 2876843,
+      "files": [
+        {
+          "path": "gliner2_base_record_anchorless_fp32_F8_C192_I1536.mlpackage/Data/com.apple.CoreML/model.mlmodel",
+          "bytes": 4994,
+          "sha256": "fa573f67c4b36f80f02668d377abd244956d1afba07be7d55866080b8188b6ef"
+        },
+        {
+          "path": "gliner2_base_record_anchorless_fp32_F8_C192_I1536.mlpackage/Data/com.apple.CoreML/weights/weight.bin",
+          "bytes": 2871232,
+          "sha256": "f48cb084768846394746b4a39d189a47be19392708075f854af3dfe8076db4cd"
+        },
+        {
+          "path": "gliner2_base_record_anchorless_fp32_F8_C192_I1536.mlpackage/Manifest.json",
+          "bytes": 617,
+          "sha256": "f646f499b1c601271b51c1420dc21ffc68fc983e2a65d4377a2094a094992385"
+        }
+      ]
+    },
+    {
+      "package": "gliner2_base_record_assignment_fp16_F8_C192_I1536.mlpackage",
+      "bytes": 605158,
+      "files": [
+        {
+          "path": "gliner2_base_record_assignment_fp16_F8_C192_I1536.mlpackage/Data/com.apple.CoreML/model.mlmodel",
+          "bytes": 9981,
+          "sha256": "5ff5970e8851aeae902aac01e4c4586d453b0f39797f342d9a9b2a2791d7e605"
+        },
+        {
+          "path": "gliner2_base_record_assignment_fp16_F8_C192_I1536.mlpackage/Data/com.apple.CoreML/weights/weight.bin",
+          "bytes": 594560,
+          "sha256": "d59545d5a9df722194e38a0a3ee03c6a5f95c58fa9608f4b2f3f6e3f56d0136e"
+        },
+        {
+          "path": "gliner2_base_record_assignment_fp16_F8_C192_I1536.mlpackage/Manifest.json",
+          "bytes": 617,
+          "sha256": "365d8c13d2a88c83072fa7ec640919f817ad87b245c10caf1445cfde6e0dd040"
+        }
+      ]
+    },
+    {
+      "package": "gliner2_base_record_assignment_fp32_F8_C192_I1536.mlpackage",
+      "bytes": 1196559,
+      "files": [
+        {
+          "path": "gliner2_base_record_assignment_fp32_F8_C192_I1536.mlpackage/Data/com.apple.CoreML/model.mlmodel",
+          "bytes": 7462,
+          "sha256": "63cad042b4d8487a0e6f57eec23a6a69f8687c33720c5213b8d52c1dd2169572"
+        },
+        {
+          "path": "gliner2_base_record_assignment_fp32_F8_C192_I1536.mlpackage/Data/com.apple.CoreML/weights/weight.bin",
+          "bytes": 1188480,
+          "sha256": "5f870796d2a8e0539b20964ebcd80cae65677ed11d4b36b12df9a21d158181c1"
+        },
+        {
+          "path": "gliner2_base_record_assignment_fp32_F8_C192_I1536.mlpackage/Manifest.json",
+          "bytes": 617,
+          "sha256": "991014787fc73007fc398cfe7c77537d241c730ca8363697f2e70478389b95f8"
+        }
+      ]
+    },
+    {
+      "package": "gliner2_base_relation_fp16_W64_R4_P256.mlpackage",
+      "bytes": 11848707,
+      "files": [
+        {
+          "path": "gliner2_base_relation_fp16_W64_R4_P256.mlpackage/Data/com.apple.CoreML/model.mlmodel",
+          "bytes": 32410,
+          "sha256": "e6562f5850272ffe0b38363da5a85a70492e170e547f58b008021b6a8aa375ec"
+        },
+        {
+          "path": "gliner2_base_relation_fp16_W64_R4_P256.mlpackage/Data/com.apple.CoreML/weights/weight.bin",
+          "bytes": 11815680,
+          "sha256": "1577561a8686c9657ec38df97ff701cbc7b588da3efae6404e33622ab1cc77e5"
+        },
+        {
+          "path": "gliner2_base_relation_fp16_W64_R4_P256.mlpackage/Manifest.json",
+          "bytes": 617,
+          "sha256": "a79be16e25f1d7b5a261a8a2f1a5cd7dea41fc2d18e755338bab5dabf024662c"
+        }
+      ]
+    },
+    {
+      "package": "gliner2_base_relation_fp32_W64_R4_P256.mlpackage",
+      "bytes": 23661032,
+      "files": [
+        {
+          "path": "gliner2_base_relation_fp32_W64_R4_P256.mlpackage/Data/com.apple.CoreML/model.mlmodel",
+          "bytes": 29823,
+          "sha256": "5970ae822c86e3f11ef86341034824661fa10184730953ac4bcdb7086e87a6ea"
+        },
+        {
+          "path": "gliner2_base_relation_fp32_W64_R4_P256.mlpackage/Data/com.apple.CoreML/weights/weight.bin",
+          "bytes": 23630592,
+          "sha256": "1dd7c8e640688002c174080710cc5ba3fa32c5dc399b52ef0bf7f4c5ef8d01cb"
+        },
+        {
+          "path": "gliner2_base_relation_fp32_W64_R4_P256.mlpackage/Manifest.json",
+          "bytes": 617,
+          "sha256": "22d5d1c3db4225665d32ae55f8266c9c3ff6980bfe7c60db655529b8dfefbba9"
+        }
+      ]
+    }
+  ],
+  "runtime_files": [
+    {
+      "path": "config.json",
+      "bytes": 3150,
+      "sha256": "0eb92d00584d613aab32b2178f84a85176b62c87ae3689ce9084e83f6eba64d1"
+    },
+    {
+      "path": "tokenizer/tokenizer_config.json",
+      "bytes": 645,
+      "sha256": "0bf3ea0873234bd9bfdd3853c440395009ac6365a925b91654daed5396d655e1"
+    },
+    {
+      "path": "tokenizer/tokenizer.json",
+      "bytes": 8341713,
+      "sha256": "cbc8ae6037812709c9c26f2a160f8dc48b0440bcb79c8141804259ae2d6adac3"
+    }
+  ]
+}

extraction_export.py

@@ -0,0 +1,408 @@
+"""Core ML graph wrappers for GLiNER2.5's trained boundary extraction path."""
+
+import math
+from contextlib import contextmanager
+
+import torch
+from coremltools.converters.mil import Builder as mb
+from coremltools.converters.mil.frontend.torch.ops import _get_inputs
+from coremltools.converters.mil.frontend.torch.torch_op_registry import register_torch_op
+from coremltools.converters.mil.mil import types
+from gliner2.models.boundary import encoding, heads
+from gliner2.models.boundary.pool import PooledCandidates
+from gliner2.models.boundary.proposal import BoundaryProposals
+from transformers.models.deberta_v2 import modeling_deberta_v2
+
+from export_model import coreml_safe_attention_forward
+
+
+@register_torch_op(override=True)
+def clamp_min(context, node):
+    """Preserve the tensor dtype when TorchScript supplied a Python scalar."""
+    x, y = _get_inputs(context, node, expected=2)
+    if x.dtype != y.dtype:
+        y = mb.cast(x=y, dtype=types.builtin_to_string(x.dtype))
+    context.add(mb.maximum(x=x, y=y, name=node.name))
+
+
+@register_torch_op(torch_alias=["clip"], override=True)
+def clamp(context, node):
+    """Avoid promoting integer span indices to float for an absent bound."""
+    inputs = _get_inputs(context, node, expected=[1, 2, 3])
+    x = inputs[0]
+    lower = inputs[1] if len(inputs) > 1 and inputs[1] is not None else None
+    upper = inputs[2] if len(inputs) > 2 and inputs[2] is not None else None
+    result = x
+    for bound, op in ((upper, mb.minimum), (lower, mb.maximum)):
+        if bound is None:
+            continue
+        if bound.dtype != x.dtype:
+            bound = mb.cast(x=bound, dtype=types.builtin_to_string(x.dtype))
+        result = op(x=result, y=bound)
+    context.add(mb.identity(x=result, name=node.name))
+
+
+def shift_left(text_states, bos_state):
+    """Functional equivalent of the upstream in-place BOS placement."""
+    bos = bos_state.to(text_states.dtype).view(1, 1, -1)
+    return torch.cat((bos.expand(text_states.shape[0], 1, -1), text_states), 1)
+
+
+def shift_right(text_states, text_lengths, eos_state):
+    """Functional equivalent of the upstream in-place EOS placement."""
+    batch, length, hidden = text_states.shape
+    eos = eos_state.to(text_states.dtype).view(1, 1, hidden)
+    right = torch.cat((text_states, eos.expand(batch, 1, hidden)), 1)
+    positions = torch.arange(length + 1, device=text_states.device).view(1, length + 1, 1)
+    return torch.where(
+        positions == text_lengths.view(batch, 1, 1),
+        eos.expand(batch, length + 1, hidden),
+        right,
+    )
+
+
+def safe_boundary_attention(self, states, mask):
+    """Explicit scaled attention with the same finite masked result as upstream."""
+    batch, length, dim = states.shape
+    qkv = self.qkv_projection(self.norm(states)).view(batch, length, 3, self.num_heads, self.head_dim)
+    query, key, value = qkv.permute(2, 0, 3, 1, 4)
+    allowed = mask.view(batch, 1, 1, length).expand(batch, 1, length, length)
+    if self.window > 0:
+        positions = torch.arange(length, device=states.device)
+        local = (positions.view(length, 1) - positions.view(1, length)).abs() <= self.window
+        allowed = allowed & local.view(1, 1, length, length)
+    diagonal = torch.eye(length, dtype=torch.bool, device=states.device).view(1, 1, length, length)
+    allowed = (allowed.float() + diagonal.float()) > 0.5
+    scores = torch.matmul(query, key.transpose(-1, -2)) / math.sqrt(self.head_dim)
+    scores = scores.masked_fill(~allowed, -1e4)
+    attended = torch.matmul(torch.softmax(scores, dim=-1), value)
+    attended = attended.transpose(1, 2).reshape(batch, length, dim)
+    return (states + self.dropout(self.output_projection(attended))) * mask.unsqueeze(-1).to(states.dtype)
+
+
+def safe_query_head(self, boundary, boundary_mask, text, text_mask, query, query_mask):
+    """Upstream marginals with a dtype-safe count clamp for Core ML."""
+    scale = 1.0 / math.sqrt(self.boundary_dim)
+    start = (
+        torch.einsum(
+            "bld,bqd->bql",
+            self.dropout(self.start_boundary_projection(boundary)),
+            self.start_query_projection(query),
+        )
+        * scale
+    )
+    end = (
+        torch.einsum(
+            "bld,bqd->bql",
+            self.dropout(self.end_boundary_projection(boundary)),
+            self.end_query_projection(query),
+        )
+        * scale
+    )
+    inside = (
+        torch.einsum(
+            "bld,bqd->bql",
+            self.dropout(self.inside_text_projection(text)),
+            self.inside_query_projection(query),
+        )
+        * scale
+    )
+    boundary_keep = boundary_mask.unsqueeze(1) & query_mask.unsqueeze(-1)
+    text_keep = text_mask.unsqueeze(1) & query_mask.unsqueeze(-1)
+    start = heads._masked_fill_min(start, boundary_keep)
+    end = heads._masked_fill_min(end, boundary_keep)
+    inside = heads._masked_fill_min(inside, text_keep)
+    inside_for_prefix = inside.masked_fill(~text_keep, 0.0).float()
+    count = torch.clamp(text_keep.sum(-1, keepdim=True).float(), min=1.0)
+    mean = (inside_for_prefix.sum(-1, keepdim=True) / count).detach()
+    centered = (inside_for_prefix - mean) * text_keep.to(inside_for_prefix.dtype)
+    zeros = torch.zeros(centered.shape[0], centered.shape[1], 1, dtype=torch.float32, device=text.device)
+    prefix = torch.cat((zeros, centered.cumsum(dim=-1)), dim=-1)
+    return heads.BoundaryMarginals(start, end, inside, prefix, mean)
+
+
+@contextmanager
+def coreml_trace_patches():
+    """Apply and restore mathematically equivalent trace-safe operations."""
+    saved = (
+        modeling_deberta_v2.scaled_size_sqrt,
+        modeling_deberta_v2.build_rpos,
+        modeling_deberta_v2.DisentangledSelfAttention.forward,
+        encoding.shift_left_with_bos,
+        encoding.shift_right_with_eos,
+        encoding.BoundaryAttentionBlock.forward,
+        heads.BoundaryQueryHead.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
+    modeling_deberta_v2.build_rpos = lambda query, key, relative_pos, buckets, max_pos: relative_pos
+    modeling_deberta_v2.DisentangledSelfAttention.forward = coreml_safe_attention_forward
+    encoding.shift_left_with_bos = shift_left
+    encoding.shift_right_with_eos = shift_right
+    encoding.BoundaryAttentionBlock.forward = safe_boundary_attention
+    heads.BoundaryQueryHead.forward = safe_query_head
+    try:
+        yield
+    finally:
+        (
+            modeling_deberta_v2.scaled_size_sqrt,
+            modeling_deberta_v2.build_rpos,
+            modeling_deberta_v2.DisentangledSelfAttention.forward,
+            encoding.shift_left_with_bos,
+            encoding.shift_right_with_eos,
+            encoding.BoundaryAttentionBlock.forward,
+            heads.BoundaryQueryHead.forward,
+        ) = saved
+
+
+class ExtractionFeaturesExport(torch.nn.Module):
+    """Trained encoder, boundary marginals, pool projections and null/count heads."""
+
+    def __init__(self, native):
+        super().__init__()
+        self.encoder = native.encoder
+        self.head = native.boundary_head
+        self.classifier = native.classifier
+
+    def forward(
+        self,
+        input_ids,
+        attention_mask,
+        text_indices,
+        text_mask,
+        query_indices,
+        query_mask,
+        cls_indices,
+        cls_mask,
+    ):
+        hidden = self.encoder(input_ids=input_ids.long(), attention_mask=attention_mask.long()).last_hidden_state
+        text_idx = text_indices.long().unsqueeze(-1).expand(-1, -1, hidden.shape[-1])
+        query_idx = query_indices.long().unsqueeze(-1).expand(-1, -1, hidden.shape[-1])
+        text = hidden.gather(1, text_idx) * text_mask.unsqueeze(-1)
+        query = hidden.gather(1, query_idx) * query_mask.unsqueeze(-1)
+        cls_idx = cls_indices.long().unsqueeze(-1).expand(-1, -1, hidden.shape[-1])
+        classification_states = hidden.gather(1, cls_idx)
+        classification_logits = self.classifier(classification_states).squeeze(-1)
+        classification_logits = torch.where(
+            cls_mask > 0.5, classification_logits, torch.full_like(classification_logits, -1e4)
+        )
+        tm, qm = text_mask > 0.5, query_mask > 0.5
+        encoded = self.head.boundary_encoder(text, tm)
+        marginal = self.head.boundary_query_head(encoded.states, encoded.mask, text, tm, query, qm)
+        return (
+            text,
+            query,
+            encoded.states,
+            encoded.mask.float(),
+            marginal.start_logits,
+            marginal.end_logits,
+            marginal.inside_prefix,
+            marginal.inside_prefix_mean,
+            self.head.shared_pool_builder.start_projection(encoded.states),
+            self.head.shared_pool_builder.end_projection(encoded.states),
+            self.head.null_projection(query).squeeze(-1),
+            self.head.count_head(query).squeeze(-1),
+            classification_logits,
+        )
+
+
+class ExtractionScoreExport(torch.nn.Module):
+    """Trained shared-pool reranker and record candidate state projection."""
+
+    def __init__(self, native):
+        super().__init__()
+        self.scorer = native.boundary_head.shared_pool_scorer
+        self.candidate_encoder = native.boundary_head.candidate_encoder
+
+    def forward(
+        self,
+        text,
+        text_mask,
+        query,
+        query_mask,
+        boundary,
+        starts,
+        ends,
+        inside,
+        inside_mean,
+        indices,
+        pool_mask,
+        compatibility,
+    ):
+        tm, qm = text_mask > 0.5, query_mask > 0.5
+        pooled = PooledCandidates(indices.long(), pool_mask > 0.5, None, None, compatibility)
+        score, _ = self.scorer(
+            boundary,
+            query,
+            qm,
+            pooled,
+            starts,
+            ends,
+            inside,
+            tm.sum(-1).long(),
+            text,
+            tm,
+            inside_prefix_mean=inside_mean,
+        )
+        index = indices.long()
+        start_states = boundary.gather(1, index[..., 0].unsqueeze(-1).expand(-1, -1, boundary.shape[-1]))
+        end_states = boundary.gather(1, index[..., 1].unsqueeze(-1).expand(-1, -1, boundary.shape[-1]))
+        candidate_states = self.candidate_encoder(torch.cat((start_states, end_states), -1))
+        candidate_states = candidate_states * pool_mask.unsqueeze(-1)
+        return score.transpose(1, 2), candidate_states
+
+
+class ExtractionRelationExport(torch.nn.Module):
+    """The trained sparse relation scorer with tensor-only pair routing."""
+
+    def __init__(self, native):
+        super().__init__()
+        self.scorer = native.relation_scorer
+
+    def forward(
+        self,
+        text,
+        text_length,
+        relation,
+        batch_index,
+        relation_index,
+        head_start,
+        head_end,
+        tail_start,
+        tail_end,
+        pair_mask,
+    ):
+        scorer = self.scorer
+        length = text.shape[1]
+        batch_valid = (batch_index >= 0) & (batch_index < text.shape[0])
+        relation_valid = (relation_index >= 0) & (relation_index < relation.shape[1])
+        valid = batch_valid & relation_valid & (pair_mask > 0.5)
+        batch = batch_index.long().clamp(0, text.shape[0] - 1)
+        rel_index = relation_index.long().clamp(0, relation.shape[1] - 1)
+
+        def gather(position):
+            return text[batch, position.long().clamp(0, length - 1)]
+
+        h_start = gather(head_start)
+        h_end = gather(head_end - 1)
+        t_start = gather(tail_start)
+        t_end = gather(tail_end - 1)
+        rel = relation[batch, rel_index]
+        delta = (tail_start - head_start).to(text.dtype)
+        order = torch.sign(delta).unsqueeze(-1)
+        distance = (delta.abs() / text_length.float().clamp_min(1.0)).unsqueeze(-1)
+        features = torch.cat((h_start, h_end, t_start, t_end, rel, order, distance), -1)
+        score = scorer.mlp(features).squeeze(-1)
+        if scorer.use_biaffine_content:
+            prefix = torch.cat(
+                (text.new_zeros(text.shape[0], 1, scorer.hidden_size), text.float().cumsum(1).to(text.dtype)),
+                dim=1,
+            )
+
+            def pool(start, end):
+                total = prefix[batch, end.long().clamp(0, length)] - prefix[batch, start.long().clamp(0, length)]
+                width = (end - start).clamp_min(1).unsqueeze(-1).to(total.dtype)
+                return total / width
+
+            head_content = scorer.head_content_projection(pool(head_start, head_end))
+            tail_content = scorer.tail_content_projection(pool(tail_start, tail_end))
+            gate = torch.sigmoid(scorer.relation_content_gate(rel))
+            biaffine = (head_content * gate * tail_content).sum(-1) / (scorer.hidden_size**0.5)
+            linear = scorer.content_linear(torch.cat((head_content, tail_content, rel), -1)).squeeze(-1)
+            score = score + biaffine + linear
+        return score.masked_fill(~valid, 0.0)
+
+
+class ExtractionRecordAssignmentExport(torch.nn.Module):
+    """All trained natural/latent/anchorless object and field assignment layers."""
+
+    def __init__(self, native):
+        super().__init__()
+        self.head = native.record_decoder
+
+    def forward(self, instances, field_queries, field_candidates):
+        head = self.head
+        instance_projection = head.inst_proj(instances)
+        field_projection = head.field_proj(field_queries)
+        query = instance_projection.unsqueeze(1) + field_projection.unsqueeze(0)
+        null_scores = torch.einsum("ifd,d->if", query, head.null_embed)
+        candidate_scores = torch.einsum("ifd,fcd->ifc", query, head.cand_proj(field_candidates))
+        assignment = torch.cat((null_scores.unsqueeze(-1), candidate_scores), -1)
+        object_scores = head.object_head(instances).squeeze(-1)
+        latent_scores = head.latent_seed_head(instances).squeeze(-1)
+        return assignment, object_scores, latent_scores
+
+
+class ExtractionRecordAnchorlessExport(torch.nn.Module):
+    """Trained learned-instance and contextual attention path for records."""
+
+    def __init__(self, native):
+        super().__init__()
+        self.head = native.record_decoder
+
+    def forward(self, context_states, context_mask):
+        head = self.head
+        instances = head.instance_embed
+        query = head.q_proj(instances)
+        key = head.k_proj(context_states)
+        value = head.v_proj(context_states)
+        attention = torch.matmul(query, key.transpose(-1, -2)) / math.sqrt(head.record_dim)
+        attention = attention.masked_fill(context_mask.unsqueeze(0) < 0.5, -1e4)
+        pooled = torch.matmul(torch.softmax(attention, -1), value)
+        return instances + pooled * (context_mask.sum() > 0).to(pooled.dtype)
+
+
+class ExtractionExplicitSpanExport(torch.nn.Module):
+    """Trained proposal prior and reranker for forced attribute/enum spans."""
+
+    def __init__(self, native):
+        super().__init__()
+        self.proposer = native.boundary_head.boundary_proposer
+        self.scorer = native.boundary_head.pair_scorer
+
+    def forward(
+        self,
+        text,
+        text_mask,
+        query,
+        query_mask,
+        boundary,
+        starts,
+        ends,
+        inside,
+        inside_mean,
+        indices,
+        valid_mask,
+    ):
+        tm, qm = text_mask > 0.5, query_mask > 0.5
+        idx = indices.long()
+        legal = (
+            (idx[..., 0] >= 0)
+            & (idx[..., 1] > idx[..., 0])
+            & (idx[..., 1] <= tm.sum(-1).view(-1, 1, 1))
+            & qm.unsqueeze(-1)
+            & (valid_mask > 0.5)
+        )
+        compatibility = self.proposer.score_explicit_pairs(boundary, query, idx, legal)
+        proposals = BoundaryProposals(
+            indices=idx,
+            logits=None,
+            valid_mask=legal,
+            compat_logits=compatibility,
+        )
+        return self.scorer(
+            boundary,
+            query,
+            proposals,
+            starts,
+            ends,
+            inside,
+            tm.sum(-1).long(),
+            text,
+            tm,
+            inside_prefix_mean=inside_mean,
+        )

extraction_pool.py

@@ -0,0 +1,117 @@
+"""Weight-free GLiNER2 boundary candidate selection between Core ML stages.
+
+The learned start/end projections are outputs of the first Core ML stage. This
+module preserves GLiNER2 2.0.0's stable ranking and deduplication on the host.
+"""
+
+import math
+
+import torch
+from gliner2.models.boundary.constants import MASK_LOGIT
+from gliner2.models.boundary.indexing import gather_rows
+from gliner2.models.boundary.pool import PooledCandidates, _deduplicate_pool
+from gliner2.models.boundary.proposal import select_top_boundaries
+
+
+def select_candidates(
+    start_projection: torch.Tensor,
+    end_projection: torch.Tensor,
+    boundary_mask: torch.Tensor,
+    query_mask: torch.Tensor,
+    start_logits: torch.Tensor,
+    end_logits: torch.Tensor,
+    *,
+    boundary_top_k: int,
+    pool_size: int,
+    min_pool_per_query: int,
+) -> PooledCandidates:
+    """Select the native shared pool using already projected Core ML states."""
+    batch, n_boundaries, dim = start_projection.shape
+    n_queries = query_mask.shape[1]
+    if end_projection.shape != start_projection.shape:
+        raise ValueError("Start and end projections must have the same shape")
+    if start_logits.shape != (batch, n_queries, n_boundaries):
+        raise ValueError("Start logits do not match boundary and query dimensions")
+    if end_logits.shape != start_logits.shape:
+        raise ValueError("End logits do not match start logits")
+    if boundary_mask.shape != (batch, n_boundaries) or query_mask.shape != (batch, n_queries):
+        raise ValueError("Boundary or query mask has an unexpected shape")
+
+    floor = torch.full_like(start_logits, MASK_LOGIT)
+    valid_boundary = boundary_mask.unsqueeze(1) & query_mask.unsqueeze(-1)
+    union_start = torch.where(valid_boundary, start_logits, floor).amax(1)
+    union_end = torch.where(valid_boundary, end_logits, floor).amax(1)
+    union_valid = boundary_mask & query_mask.any(-1, keepdim=True)
+    _, starts, starts_valid = select_top_boundaries(union_start.unsqueeze(1), union_valid.unsqueeze(1), boundary_top_k)
+    _, ends, ends_valid = select_top_boundaries(union_end.unsqueeze(1), union_valid.unsqueeze(1), boundary_top_k)
+    starts, ends = starts[:, 0], ends[:, 0]
+    starts_valid, ends_valid = starts_valid[:, 0], ends_valid[:, 0]
+    n_starts, n_ends = starts.shape[1], ends.shape[1]
+    pair_start = starts.unsqueeze(-1).expand(batch, n_starts, n_ends).reshape(batch, -1)
+    pair_end = ends.unsqueeze(1).expand(batch, n_starts, n_ends).reshape(batch, -1)
+    pair_valid = (
+        starts_valid.unsqueeze(-1) & ends_valid.unsqueeze(1) & (ends.unsqueeze(1) > starts.unsqueeze(-1))
+    ).reshape(batch, -1)
+
+    selected_start = gather_rows(start_projection, pair_start)
+    selected_end = gather_rows(end_projection, pair_end)
+    compatibility = (selected_start * selected_end).sum(-1) / math.sqrt(dim)
+    union_pair_score = (
+        compatibility
+        + union_start.gather(1, pair_start.clamp(0, n_boundaries - 1))
+        + union_end.gather(1, pair_end.clamp(0, n_boundaries - 1))
+    )
+
+    quota = min(min_pool_per_query, pair_start.shape[-1])
+    quota_keys = pair_start.new_zeros((batch, 0))
+    quota_scores = union_pair_score.new_zeros((batch, 0))
+    quota_valid = pair_valid.new_zeros((batch, 0))
+    if quota:
+        start_idx = pair_start.clamp(0, start_logits.shape[2] - 1).unsqueeze(1).expand(batch, n_queries, -1)
+        end_idx = pair_end.clamp(0, end_logits.shape[2] - 1).unsqueeze(1).expand(batch, n_queries, -1)
+        per_query = start_logits.gather(2, start_idx) + end_logits.gather(2, end_idx) + compatibility.unsqueeze(1)
+        per_query_valid = pair_valid.unsqueeze(1) & query_mask.unsqueeze(-1)
+        ranked = torch.argsort(
+            per_query.masked_fill(~per_query_valid, MASK_LOGIT),
+            dim=-1,
+            descending=True,
+            stable=True,
+        )[..., :quota]
+        quota_start = start_idx.gather(-1, ranked)
+        quota_end = end_idx.gather(-1, ranked)
+        quota_valid = per_query_valid.gather(-1, ranked).reshape(batch, -1)
+        quota_keys = (quota_start * n_boundaries + quota_end).reshape(batch, -1)
+        rank_bonus = torch.arange(quota, 0, -1, device=start_projection.device, dtype=union_pair_score.dtype)
+        quota_scores = (
+            union_pair_score.new_full((batch, n_queries, quota), -MASK_LOGIT * 0.5) + rank_bonus.view(1, 1, quota)
+        ).reshape(batch, -1)
+
+    global_keys = pair_start * n_boundaries + pair_end
+    all_keys = torch.cat((quota_keys, global_keys), -1)
+    all_scores = torch.cat((quota_scores, union_pair_score.detach()), -1)
+    all_valid = torch.cat((quota_valid, pair_valid), -1)
+    selected_keys, selected_valid = _deduplicate_pool(all_keys, all_scores, all_valid, pool_size, n_boundaries)
+    selected_keys = torch.where(selected_valid, selected_keys, torch.zeros_like(selected_keys))
+    selected_s = torch.div(selected_keys, n_boundaries, rounding_mode="floor")
+    selected_e = selected_keys - selected_s * n_boundaries
+    indices = torch.stack((selected_s, selected_e), -1)
+    indices = torch.where(selected_valid.unsqueeze(-1), indices, torch.zeros_like(indices))
+
+    gathered_start = gather_rows(start_projection, selected_s)
+    gathered_end = gather_rows(end_projection, selected_e)
+    selected_compat = (gathered_start * gathered_end).sum(-1) / math.sqrt(dim)
+    selected_score = (
+        selected_compat
+        + union_start.gather(1, selected_s.clamp(0, n_boundaries - 1))
+        + union_end.gather(1, selected_e.clamp(0, n_boundaries - 1))
+    )
+    selected_score = selected_score.masked_fill(~selected_valid, MASK_LOGIT)
+    selected_compat = torch.where(selected_valid, selected_compat, torch.zeros_like(selected_compat))
+    return PooledCandidates(
+        indices=indices,
+        mask=selected_valid,
+        proposal_logits=selected_score,
+        gold_mask=None,
+        compat_logits=selected_compat,
+        stats=None,
+    )

extraction_runtime.py

@@ -0,0 +1,525 @@
+"""GLiNER2.5 base extraction runtime using only Core ML trained weights."""
+
+import json
+from contextvars import ContextVar
+from pathlib import Path
+
+import coremltools as ct
+import numpy as np
+import torch
+from gliner2.configuration import BoundaryHeadSettings
+from gliner2.models.boundary.engine import BoundaryExtractor
+from gliner2.models.boundary.records import RecordGroupOutput
+from gliner2.models.boundary.relations import (
+    RelationProposalSettings,
+    RelationTypeSpec,
+    TypedRelationPairGenerator,
+)
+from gliner2.models.outputs import CandidateTensorBatch, ExtractorOutput
+
+from convert_extraction_names import FEATURE_NAMES, SCORE_INPUT_NAMES
+from extraction_pool import select_candidates
+from preprocessing import load_processor, prepare_extraction
+
+MODEL_PREFIX = "gliner2_base"
+
+
+def to_tensor(value):
+    return torch.from_numpy(np.asarray(value).copy())
+
+
+def padded(value, size):
+    if value.shape[0] > size:
+        raise ValueError(f"Request exceeds Core ML bucket capacity {size}")
+    result = value.new_zeros((size, *value.shape[1:]))
+    result[: value.shape[0]] = value
+    return result
+
+
+class CoreMLBoundaryHead(torch.nn.Module):
+    """Provide native decoder tensors from the converted extraction stages."""
+
+    def __init__(self, context: ContextVar, explicit_model, max_queries: int, max_spans: int):
+        super().__init__()
+        self.context = context
+        self.explicit_model = explicit_model
+        self.max_queries = max_queries
+        self.max_spans = max_spans
+
+    def forward(self, text, text_mask, query, query_mask, return_candidates=True):
+        state = self.context.get()
+        features = state["features"]
+        full = state["candidates"]
+        count = query.shape[1]
+        selected = CandidateTensorBatch(
+            indices=full.indices[:, :count],
+            proposal_logits=full.proposal_logits[:, :count],
+            pair_logits=full.pair_logits[:, :count],
+            valid_mask=full.valid_mask[:, :count],
+            query_mask=full.query_mask[:, :count],
+            candidate_states=full.candidate_states[:, :count],
+        )
+        return ExtractorOutput(
+            candidates=selected if return_candidates else None,
+            start_logits=features["start_logits"][:, :count],
+            end_logits=features["end_logits"][:, :count],
+            null_logits=features["null_logits"][:, :count],
+            count_log_rates=features["count_log_rates"][:, :count],
+            batch_size=1,
+        )
+
+    def score_explicit_spans(self, text, text_mask, query, query_mask, indices, valid_mask=None):
+        state = self.context.get()
+        features = state["features"]
+        full_queries = features["query_states"][0]
+        active_queries = int(state["arrays"]["query_mask"].sum())
+        query_count = query.shape[1]
+        span_count = indices.shape[2]
+        if query_count > self.max_queries or span_count > self.max_spans:
+            raise ValueError("Explicit-span request exceeds Core ML bucket capacity")
+        selected = []
+        for row in query[0]:
+            equal = torch.isclose(full_queries[:active_queries], row, atol=1e-6, rtol=0).all(-1)
+            matches = equal.nonzero(as_tuple=False).flatten()
+            if matches.numel() != 1:
+                raise ValueError("Explicit-span query cannot be mapped to the encoded schema")
+            selected.append(int(matches[0]))
+        selection = torch.tensor(selected, dtype=torch.long)
+        query_states = padded(query[0], self.max_queries).unsqueeze(0)
+        query_mask_padded = padded(query_mask[0].float(), self.max_queries).unsqueeze(0)
+
+        def selected_feature(name):
+            source = features[name][0].index_select(0, selection)
+            return padded(source, self.max_queries).unsqueeze(0)
+
+        span_indices = torch.zeros(1, self.max_queries, self.max_spans, 2, dtype=torch.int32)
+        span_mask = torch.zeros(1, self.max_queries, self.max_spans, dtype=torch.float32)
+        span_indices[:, :query_count, :span_count] = indices.int()
+        span_mask[:, :query_count, :span_count] = valid_mask.float() if valid_mask is not None else 1.0
+        values = (
+            text,
+            text_mask.float(),
+            query_states,
+            query_mask_padded,
+            features["boundary_states"],
+            selected_feature("start_logits"),
+            selected_feature("end_logits"),
+            selected_feature("inside_prefix"),
+            selected_feature("inside_prefix_mean"),
+            span_indices,
+            span_mask,
+        )
+        names = (
+            "text_states",
+            "text_mask",
+            "query_states",
+            "query_mask",
+            "boundary_states",
+            "start_logits",
+            "end_logits",
+            "inside_prefix",
+            "inside_prefix_mean",
+            "span_indices",
+            "span_mask",
+        )
+        output = self.explicit_model.predict(
+            {
+                name: value.numpy().astype(np.int32 if name == "span_indices" else np.float32)
+                for name, value in zip(names, values)
+            }
+        )["span_logits"]
+        return to_tensor(output)[:, :query_count, :span_count]
+
+
+class CoreMLRelationScorer(torch.nn.Module):
+    """Call the trained Core ML relation graph after native pair selection."""
+
+    def __init__(self, context: ContextVar, model, max_words: int, max_relations: int, pair_cap: int):
+        super().__init__()
+        self.context = context
+        self.model = model
+        self.max_words = max_words
+        self.max_relations = max_relations
+        self.pair_cap = pair_cap
+
+    def forward(self, text, relation, candidates, pairs):
+        count = len(pairs)
+        if text.shape[1] != self.max_words or relation.shape[1] > self.max_relations or count > self.pair_cap:
+            raise ValueError("Relation request exceeds Core ML bucket capacity")
+        relation_states = torch.zeros(1, self.max_relations, relation.shape[-1], dtype=relation.dtype)
+        relation_states[:, : relation.shape[1]] = relation
+        state = self.context.get()
+        text_length = int(state["arrays"]["text_mask"].sum())
+        fields = (
+            text,
+            torch.tensor([text_length], dtype=torch.int32),
+            relation_states,
+            padded(pairs.batch_index.int(), self.pair_cap),
+            padded(pairs.relation_index.int(), self.pair_cap),
+            padded(pairs.head_start.int(), self.pair_cap),
+            padded(pairs.head_end.int(), self.pair_cap),
+            padded(pairs.tail_start.int(), self.pair_cap),
+            padded(pairs.tail_end.int(), self.pair_cap),
+            padded(pairs.pair_mask.float(), self.pair_cap),
+        )
+        names = (
+            "text_states",
+            "text_length",
+            "relation_states",
+            "batch_index",
+            "relation_index",
+            "head_start",
+            "head_end",
+            "tail_start",
+            "tail_end",
+            "pair_mask",
+        )
+        output = self.model.predict(
+            {
+                name: value.numpy().astype(
+                    np.float32 if name in ("text_states", "relation_states", "pair_mask") else np.int32
+                )
+                for name, value in zip(names, fields)
+            }
+        )["relation_logits"]
+        return to_tensor(output)[:count]
+
+
+class CoreMLRecordHead(torch.nn.Module):
+    """Keep GLiNER2's instance ordering while running learned layers in Core ML."""
+
+    def __init__(self, assignment_model, anchorless_model, max_fields=8, max_candidates=192, max_instances=1536):
+        super().__init__()
+        self.assignment_model = assignment_model
+        self.anchorless_model = anchorless_model
+        self.max_fields = max_fields
+        self.max_candidates = max_candidates
+        self.max_instances = max_instances
+
+    def forward_group(self, spec, query_states, candidates, sample_index):
+        field_specs = list(spec.fields)
+        field_query_ids = [field.query_id for field in field_specs]
+        if len(field_specs) > self.max_fields:
+            raise ValueError("Record has more fields than the Core ML bucket")
+        query_count = query_states.shape[0]
+        if any(query_id < 0 or query_id >= query_count for query_id in field_query_ids):
+            raise ValueError("Record field query is outside the encoded schema")
+        field_states, field_spans, field_logits, field_masks = [], [], [], []
+        for query_id in field_query_ids:
+            mask = candidates.valid_mask[sample_index, query_id]
+            if int(mask.sum()) > self.max_candidates:
+                raise ValueError("Record candidate count exceeds Core ML bucket")
+            field_states.append(candidates.candidate_states[sample_index, query_id][mask])
+            field_spans.append(candidates.indices[sample_index, query_id][mask])
+            field_logits.append(candidates.pair_logits[sample_index, query_id][mask])
+            field_masks.append(torch.ones(int(mask.sum()), dtype=torch.bool))
+
+        instance_seed = []
+        instance_spans = []
+        if spec.mode == "natural":
+            anchor = field_query_ids.index(spec.anchor_query_id)
+            instances = field_states[anchor]
+            for index, span in enumerate(field_spans[anchor]):
+                instance_seed.append((anchor, index))
+                instance_spans.append((int(span[0]), int(span[1])))
+        elif spec.mode == "latent":
+            instances = (
+                torch.cat(field_states, 0) if field_states else query_states.new_zeros((0, query_states.shape[-1]))
+            )
+            for field_index, spans in enumerate(field_spans):
+                for index, span in enumerate(spans):
+                    instance_seed.append((field_index, index))
+                    instance_spans.append((int(span[0]), int(span[1])))
+        else:
+            context_states = (
+                torch.cat(field_states, 0) if field_states else query_states.new_zeros((0, query_states.shape[-1]))
+            )
+            context_capacity = self.max_fields * self.max_candidates
+            context_mask = torch.zeros(context_capacity, dtype=torch.float32)
+            context_mask[: context_states.shape[0]] = 1.0
+            output = self.anchorless_model.predict(
+                {
+                    "context_states": padded(context_states, context_capacity).numpy().astype(np.float32),
+                    "context_mask": context_mask.numpy(),
+                }
+            )["instance_states"]
+            instances = to_tensor(output)
+            instance_seed = [None] * instances.shape[0]
+            instance_spans = [None] * instances.shape[0]
+
+        count = instances.shape[0]
+        if count > self.max_instances:
+            raise ValueError("Record instance count exceeds Core ML bucket")
+        hidden = query_states.shape[-1]
+        candidate_states = torch.zeros(self.max_fields, self.max_candidates, hidden)
+        for index, states in enumerate(field_states):
+            candidate_states[index, : states.shape[0]] = states
+        fields = (
+            padded(instances, self.max_instances),
+            padded(query_states[field_query_ids], self.max_fields),
+            candidate_states,
+        )
+        predicted = self.assignment_model.predict(
+            {
+                name: value.numpy().astype(np.float32)
+                for name, value in zip(("instance_states", "field_queries", "field_candidate_states"), fields)
+            }
+        )
+        assignment = to_tensor(predicted["assignment_logits"])
+        assignment_by_field = [
+            assignment[:count, field_index, : 1 + states.shape[0]] for field_index, states in enumerate(field_states)
+        ]
+        if spec.mode == "natural":
+            object_logits = field_logits[field_query_ids.index(spec.anchor_query_id)]
+        elif spec.mode == "latent":
+            object_logits = to_tensor(predicted["latent_seed_logits"])[:count]
+        else:
+            object_logits = to_tensor(predicted["object_logits"])[:count]
+        return RecordGroupOutput(
+            spec=spec,
+            object_logits=object_logits,
+            assign_logits=assignment_by_field,
+            field_query_ids=field_query_ids,
+            field_specs=field_specs,
+            field_spans=field_spans,
+            field_cand_mask=field_masks,
+            field_cand_logits=field_logits,
+            instance_seed=instance_seed,
+            instance_spans=instance_spans,
+        )
+
+
+class CoreMLBoundaryExtractor(BoundaryExtractor):
+    """Native GLiNER2 schema/decoder with all trained extraction heads in Core ML."""
+
+    def __init__(self, model_dir: str, precision: str = "fp32", compute_units=ct.ComputeUnit.CPU_ONLY):
+        if precision not in ("fp16", "fp32"):
+            raise ValueError("precision must be fp16 or fp32")
+        torch.nn.Module.__init__(self)
+        folder = Path(model_dir)
+        config = json.loads((folder / "config.json").read_text())
+        self.boundary_settings = BoundaryHeadSettings(**config["boundary_head"])
+        self.processor = load_processor(str(folder / "tokenizer"))
+        self.enable_records = self.boundary_settings.enable_records
+        self.enable_relations = self.boundary_settings.enable_relations
+        self.strict_extraction = True
+        self.length, self.max_words, self.max_queries = 128, 64, 8
+        self._context = ContextVar("gliner2_coreml_extraction_context")
+        suffix = f"{precision}_L128_W64_Q8"
+        self.features_model = ct.models.MLModel(
+            str(folder / f"{MODEL_PREFIX}_extraction_features_{suffix}.mlpackage"), compute_units=compute_units
+        )
+        self.scorer_model = ct.models.MLModel(
+            str(folder / f"{MODEL_PREFIX}_extraction_scorer_{suffix}.mlpackage"), compute_units=compute_units
+        )
+        explicit = ct.models.MLModel(
+            str(folder / f"{MODEL_PREFIX}_explicit_{precision}_W64_Q8_S64.mlpackage"), compute_units=compute_units
+        )
+        relation = ct.models.MLModel(
+            str(folder / f"{MODEL_PREFIX}_relation_{precision}_W64_R4_P256.mlpackage"), compute_units=compute_units
+        )
+        assignment = ct.models.MLModel(
+            str(folder / f"{MODEL_PREFIX}_record_assignment_{precision}_F8_C192_I1536.mlpackage"),
+            compute_units=compute_units,
+        )
+        anchorless = ct.models.MLModel(
+            str(folder / f"{MODEL_PREFIX}_record_anchorless_{precision}_F8_C192_I1536.mlpackage"),
+            compute_units=compute_units,
+        )
+        self.boundary_head = CoreMLBoundaryHead(self._context, explicit, self.max_queries, 64)
+        self.relation_scorer = CoreMLRelationScorer(self._context, relation, self.max_words, 4, 256)
+        self.record_decoder = CoreMLRecordHead(assignment, anchorless)
+        self.relation_pair_generator = TypedRelationPairGenerator(
+            RelationProposalSettings(
+                heads_per_relation=self.boundary_settings.relation_heads_per_type,
+                tails_per_relation=self.boundary_settings.relation_tails_per_type,
+                pair_cap=self.boundary_settings.relation_pair_cap,
+                argument_threshold=self.boundary_settings.relation_argument_proposal_threshold,
+            )
+        )
+
+    def _encode_core(self, batch):
+        features = self._context.get()["features"]
+        query_states = features["query_states"]
+        text_states = features["text_states"]
+        query_mask = to_tensor(self._context.get()["arrays"]["query_mask"]).bool()
+        query_count = int(query_mask.sum())
+        query_states = query_states[:, :query_count]
+        query_mask = query_mask[:, :query_count]
+        text_mask = to_tensor(self._context.get()["arrays"]["text_mask"]).bool()
+        ext_specs, cls_specs, rel_specs, word_offsets = [], [], [], []
+        for sample_index in range(len(batch)):
+            specs = [
+                {
+                    "group_index": item.task_index,
+                    "field_index": item.role_index,
+                    "task_type": item.task_type,
+                    "task_name": item.task_name,
+                    "field_name": item.role_name,
+                }
+                for item in batch.query_layouts[sample_index].queries
+            ]
+            ext_specs.append(specs)
+            classifications = []
+            choice_offset = 0
+            for group_index in range(batch.schema_counts[sample_index]):
+                if batch.task_types[sample_index][group_index] != "classifications":
+                    continue
+                count = max(len(batch.schema_special_indices[sample_index][group_index]) - 1, 0)
+                schema_tokens = batch.schema_tokens_list[sample_index][group_index]
+                if count:
+                    classifications.append(
+                        {
+                            "group_index": group_index,
+                            "task_name": schema_tokens[2],
+                            "schema_tokens": schema_tokens,
+                            "group_embs": features["classification_logits"][
+                                sample_index, choice_offset : choice_offset + count
+                            ],
+                        }
+                    )
+                choice_offset += count
+            cls_specs.append(classifications)
+            word_offsets.append(
+                max(int(batch.text_word_counts[sample_index]) - len(batch.start_mappings[sample_index]), 0)
+            )
+            groups = {}
+            for query_id, spec in enumerate(specs):
+                groups.setdefault(spec["group_index"], []).append(query_id)
+            relations = []
+            for group_index, role_ids in groups.items():
+                if batch.task_types[sample_index][group_index] != "relations" or len(role_ids) < 2:
+                    continue
+                head_id, tail_id = role_ids[:2]
+                role_states = query_states[sample_index, [head_id, tail_id]]
+                state = (
+                    torch.cat((role_states[0], role_states[1]), -1)
+                    if self.boundary_settings.directional_relation_states
+                    else role_states.mean(0)
+                )
+                relations.append(
+                    {
+                        "group_index": group_index,
+                        "relation_type": specs[head_id]["task_name"],
+                        "spec": RelationTypeSpec(
+                            specs[head_id]["task_name"], head_query_ids=(head_id,), tail_query_ids=(tail_id,)
+                        ),
+                        "query_state": state,
+                    }
+                )
+            rel_specs.append(relations)
+        return {
+            "text_states": text_states,
+            "text_mask": text_mask,
+            "text_lengths": text_mask.sum(-1).long(),
+            "query_states": query_states,
+            "query_mask": query_mask,
+            "ext_specs": ext_specs,
+            "cls_specs": cls_specs,
+            "rel_specs": rel_specs,
+            "word_offsets": word_offsets,
+        }
+
+    def _extract_classification_result(self, results, schema_name, schema, embs, schema_tokens, temperature=1.0):
+        cls_config = self._resolve_classification_config(schema_tokens[2], schema.get("classifications", []))
+        if cls_config is None:
+            return
+        if temperature <= 0:
+            raise ValueError("Classification temperature must be positive")
+        logits = embs / temperature
+        activation = cls_config.get("class_act", "auto")
+        multi_label = cls_config.get("multi_label", False)
+        if activation == "sigmoid" or (activation != "softmax" and multi_label):
+            probabilities = torch.sigmoid(logits)
+        else:
+            probabilities = torch.softmax(logits, dim=-1)
+        labels = cls_config["labels"]
+        if multi_label:
+            threshold = cls_config.get("cls_threshold", 0.5)
+            chosen = [
+                (labels[index], float(probabilities[index]))
+                for index in range(len(labels))
+                if float(probabilities[index]) >= threshold
+            ]
+            if not chosen:
+                best = int(probabilities.argmax())
+                chosen = [(labels[best], float(probabilities[best]))]
+            results[cls_config["task"]] = chosen
+            return
+        best = int(probabilities.argmax())
+        results[cls_config["task"]] = (labels[best], float(probabilities[best]))
+
+    def extract(
+        self,
+        text: str,
+        schema,
+        threshold: float = 0.5,
+        format_results: bool = True,
+        include_confidence: bool = False,
+        include_spans: bool = False,
+        overlap_policy=None,
+    ):
+        schema_dicts, metadata_list = self._build_schema_dicts_and_metadata([schema])
+        if overlap_policy is not None:
+            metadata_list[0]["_overlap_policy"] = self._resolved_overlap_policy(overlap_policy)
+        arrays, batch = prepare_extraction(
+            self.processor, text, schema_dicts[0], self.length, self.max_words, self.max_queries
+        )
+        predicted = self.features_model.predict(arrays)
+        features = {name: to_tensor(predicted[name]) for name in FEATURE_NAMES}
+        query_mask = to_tensor(arrays["query_mask"]).bool()
+        candidates = None
+        if bool(query_mask.any()):
+            head = self.boundary_settings
+            pool = select_candidates(
+                features["pool_start_projection"],
+                features["pool_end_projection"],
+                features["boundary_mask"].bool(),
+                query_mask,
+                features["start_logits"],
+                features["end_logits"],
+                boundary_top_k=head.pool_boundary_top_k,
+                pool_size=head.pool_size,
+                min_pool_per_query=head.min_pool_per_query,
+            )
+            values = (
+                features["text_states"],
+                to_tensor(arrays["text_mask"]),
+                features["query_states"],
+                to_tensor(arrays["query_mask"]),
+                features["boundary_states"],
+                features["start_logits"],
+                features["end_logits"],
+                features["inside_prefix"],
+                features["inside_prefix_mean"],
+                pool.indices.int(),
+                pool.mask.float(),
+                pool.compat_logits,
+            )
+            scored = self.scorer_model.predict(
+                {
+                    name: value.numpy().astype(np.int32 if name == "candidate_indices" else np.float32)
+                    for name, value in zip(SCORE_INPUT_NAMES, values)
+                }
+            )
+            candidates = CandidateTensorBatch(
+                indices=pool.indices.unsqueeze(1).expand(1, self.max_queries, -1, 2),
+                proposal_logits=pool.proposal_logits.unsqueeze(1).expand(1, self.max_queries, -1),
+                pair_logits=to_tensor(scored["pair_logits"]),
+                valid_mask=pool.mask.unsqueeze(1).expand(1, self.max_queries, -1),
+                query_mask=query_mask,
+                candidate_states=to_tensor(scored["candidate_states"]).unsqueeze(1).expand(1, self.max_queries, -1, -1),
+            )
+        token = self._context.set({"arrays": arrays, "features": features, "candidates": candidates})
+        try:
+            raw = self._extract_from_batch(batch, threshold, metadata_list, include_confidence, include_spans)[0]
+            if format_results:
+                return self.format_results(
+                    raw,
+                    include_confidence,
+                    metadata_list[0].get("relation_order", []),
+                    metadata_list[0].get("classification_tasks", []),
+                )
+            return raw
+        finally:
+            self._context.reset(token)

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

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

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

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

gliner2_base_explicit_fp16_W64_Q8_S64.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "D726DDD0-C257-44BB-B2AB-E6F00C6422DA": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        },
+        "EA5D631C-0A1C-45BC-BA64-A5F37269708E": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        }
+    },
+    "rootModelIdentifier": "EA5D631C-0A1C-45BC-BA64-A5F37269708E"
+}

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

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

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

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

gliner2_base_explicit_fp32_W64_Q8_S64.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "7CEC5B51-AEEB-4F06-BB27-342E29DF9350": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        },
+        "AD3570EB-1FD4-4674-9D29-2A3B6B2083D7": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        }
+    },
+    "rootModelIdentifier": "7CEC5B51-AEEB-4F06-BB27-342E29DF9350"
+}

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

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

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

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

gliner2_base_extraction_features_fp16_L128_W64_Q8.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "CE6FE6C9-1B05-44D1-86BE-D05BA3A90F48": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        },
+        "FABF84D1-9ACF-40E8-AD85-5BFDFA7D831E": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        }
+    },
+    "rootModelIdentifier": "FABF84D1-9ACF-40E8-AD85-5BFDFA7D831E"
+}

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

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

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

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

gliner2_base_extraction_features_fp32_L128_W64_Q8.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "27195BA1-5D5E-4583-8356-AEF31C964DF5": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        },
+        "B9ECF184-78AE-4CED-A667-63FF8B2342CE": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        }
+    },
+    "rootModelIdentifier": "B9ECF184-78AE-4CED-A667-63FF8B2342CE"
+}

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

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

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

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

gliner2_base_extraction_scorer_fp16_L128_W64_Q8.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "3FDDF70C-07D4-4EC0-B0F5-C918F277B00E": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        },
+        "44AFC159-B1AA-41A7-B5E7-7A63C4CADFB4": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        }
+    },
+    "rootModelIdentifier": "3FDDF70C-07D4-4EC0-B0F5-C918F277B00E"
+}

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

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

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

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

gliner2_base_extraction_scorer_fp32_L128_W64_Q8.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "39A0473F-D89D-43AB-A591-4D885B89F208": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        },
+        "403A1040-2367-428B-A9F2-2E969F0B9FDC": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        }
+    },
+    "rootModelIdentifier": "403A1040-2367-428B-A9F2-2E969F0B9FDC"
+}

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

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

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

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

gliner2_base_record_anchorless_fp16_F8_C192_I1536.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "299C8B61-4089-4454-B109-2D7002032011": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        },
+        "63E77F60-B2F1-4E33-9505-B84C84607AC7": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        }
+    },
+    "rootModelIdentifier": "63E77F60-B2F1-4E33-9505-B84C84607AC7"
+}

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

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

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

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

gliner2_base_record_anchorless_fp32_F8_C192_I1536.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "05BE39C5-5E8D-408A-802C-C14032032B68": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        },
+        "8059378D-AEA5-4997-8297-940F2F714C91": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        }
+    },
+    "rootModelIdentifier": "8059378D-AEA5-4997-8297-940F2F714C91"
+}

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

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

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

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

gliner2_base_record_assignment_fp16_F8_C192_I1536.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "68A464FA-A24A-46B9-9356-80E6888F5D9D": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        },
+        "A795C3EE-066E-4321-A479-969549184B3F": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        }
+    },
+    "rootModelIdentifier": "68A464FA-A24A-46B9-9356-80E6888F5D9D"
+}

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

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

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

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

gliner2_base_record_assignment_fp32_F8_C192_I1536.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "832C4AAB-6488-45A5-B0EB-42E172A71A5B": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        },
+        "E0009128-6F7C-4DFF-8EE5-473660E36248": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        }
+    },
+    "rootModelIdentifier": "E0009128-6F7C-4DFF-8EE5-473660E36248"
+}

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

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

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

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

gliner2_base_relation_fp16_W64_R4_P256.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "21433269-C580-4889-9FA2-579489ECCCB1": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        },
+        "6A4D1B00-0FCB-4AA0-B64F-43CF443BCA7C": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        }
+    },
+    "rootModelIdentifier": "6A4D1B00-0FCB-4AA0-B64F-43CF443BCA7C"
+}

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

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

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

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

gliner2_base_relation_fp32_W64_R4_P256.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "1BDDDB06-D37B-4A40-BEAB-8A1B63278068": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        },
+        "ACF6B577-6E60-42EF-B900-AA17259DF0D8": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        }
+    },
+    "rootModelIdentifier": "1BDDDB06-D37B-4A40-BEAB-8A1B63278068"
+}

preprocessing.py

@@ -1,4 +1,5 @@
 """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
@@ -10,11 +11,13 @@ 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)
 
@@ -41,3 +44,46 @@ def prepare_with_processor(processor, text: str, task: str, labels: list[str], l
         "marker_indices": indices.astype(np.int32),
         "marker_mask": mask.astype(np.float32),
     }
+
+
+def prepare_extraction(
+    processor,
+    text: str,
+    schema,
+    length: int,
+    max_words: int,
+    max_queries: int,
+    max_choices: int = 8,
+):
+    """Prepare an extractive schema without allowing upstream word truncation."""
+    if min(length, max_words, max_queries, max_choices) < 1:
+        raise ValueError("Extraction bucket dimensions must all be positive")
+    built_schema = schema.build() if hasattr(schema, "build") else schema
+    collator = ExtractorCollator(processor, is_training=False, max_len=None, architecture="boundary")
+    batch = collator([(text, built_schema)])
+    if batch.input_ids.shape[1] > length:
+        raise ValueError(f"Schema and text require {batch.input_ids.shape[1]} subwords; bucket holds {length}")
+    if batch.text_word_indices.shape[1] > max_words:
+        raise ValueError(f"Text requires {batch.text_word_indices.shape[1]} words; bucket holds {max_words}")
+    if batch.query_marker_indices.shape[1] > max_queries:
+        raise ValueError(f"Schema requires {batch.query_marker_indices.shape[1]} queries; bucket holds {max_queries}")
+    if batch.cls_marker_indices.shape[1] > max_choices:
+        raise ValueError(f"Schema requires {batch.cls_marker_indices.shape[1]} choices; bucket holds {max_choices}")
+    if batch.query_marker_indices.shape[1] == 0 and batch.cls_marker_indices.shape[1] == 0:
+        raise ValueError("Schema has no extraction or classification queries")
+
+    def padded(values, width, fill=0):
+        array = values.numpy()
+        return np.pad(array, ((0, 0), (0, width - array.shape[1])), constant_values=fill)
+
+    arrays = {
+        "input_ids": padded(batch.input_ids, length, processor.tokenizer.pad_token_id).astype(np.int32),
+        "attention_mask": padded(batch.attention_mask, length).astype(np.int32),
+        "text_indices": padded(batch.text_word_indices, max_words).astype(np.int32),
+        "text_mask": padded(batch.text_word_mask, max_words).astype(np.float32),
+        "query_indices": padded(batch.query_marker_indices, max_queries).astype(np.int32),
+        "query_mask": padded(batch.query_marker_mask, max_queries).astype(np.float32),
+        "cls_indices": padded(batch.cls_marker_indices, max_choices).astype(np.int32),
+        "cls_mask": padded(batch.cls_marker_mask, max_choices).astype(np.float32),
+    }
+    return arrays, batch

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "gliner2-base-coreml"
 version = "0.1.0"
-description = "Pinned GLiNER 2.5 small decision classifier Core ML export"
+description = "Pinned GLiNER 2.5 base Core ML classification and extraction export"
 requires-python = ">=3.12,<3.13"
 dependencies = [
     "coremltools==9.0",
@@ -9,6 +9,7 @@ dependencies = [
     "huggingface-hub>=0.34,<1",
     "numpy<2.3",
     "protobuf>=5,<7",
+    "psutil>=7,<8",
     "sentencepiece>=0.2,<0.3",
     "torch==2.7.0",
     "transformers==4.57.6",
@@ -16,6 +17,7 @@ dependencies = [
 
 [dependency-groups]
 dev = ["pytest>=8.4", "ruff>=0.13"]
+compression = ["scikit-learn==1.5.1"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]