LiteRT conversion of fastino/GLiNER2.5-Decide, with Qualcomm NPU files

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

NOTICE.txt

@@ -0,0 +1,7 @@
+GLiNER2.5-Decide (fastino/GLiNER2.5-Decide @ bbe10ff77ebb238777c17d3a8ac9260e30929057), by Fastino, licensed under the Apache License 2.0 (LICENSE). Its encoder is DeBERTa-v3-large (Microsoft, MIT License).
+
+Changes: converted to LiteRT by spybyscript (wfp16, fp16hw). The graph code (rank-4 attention, the relative-position buckets baked as constants, the FP16-hardware rewrites) is ported from litert-community/GLiNER2.5-Decide-LiteRT @ c687e899 (Apache-2.0), rewritten for one file with a signature per bucket and a per-position output. The token embedding table is shipped as a float16 file outside the graph. Weights are the original apart from the precision each variant states. Only the encoder and the classification head are exported.
+
+npu/ holds single-signature cuts of the fp16hw graph and files precompiled from it for Qualcomm Hexagon NPUs with Qualcomm's QAIRT 2.50.0 (ai-edge-litert 2.3.0); their weights are fp16hw's.
+
+model-card.md is the original model card; README.md describes this conversion.

README.md

@@ -0,0 +1,147 @@
+---
+license: apache-2.0
+language:
+- en
+base_model: fastino/GLiNER2.5-Decide
+library_name: litert
+tags:
+- gliner2
+- litert
+- tflite
+- android
+- on-device
+---
+
+# GLiNER2.5-Decide — LiteRT (Android)
+
+An on-device conversion of GLiNER2.5-Decide for Android's LiteRT: one file for every input length (about half the size of a file per length), validated against the gliner2 library on 2,338 decisions, with phone measurements and Qualcomm NPU files.
+
+Converted from [fastino/GLiNER2.5-Decide](https://huggingface.co/fastino/GLiNER2.5-Decide) at revision `bbe10ff77ebb238777c17d3a8ac9260e30929057` (Apache-2.0, by Fastino).
+One `.tflite` per variant, each with four signatures (`s128`, `s160`, `s256`, `s512`)
+that share one set of weights; the token table is a separate float16 file the host maps. `config.json` is the full contract.
+
+| File | Size | Precision |
+|---|---|---|
+| `gliner25_decide_wfp16.tflite` | 1026 MB | FULLY_CONNECTED weights stored float16 behind DEQUANTIZE (ai-edge-quantizer FLOAT_CASTING); FP32 activations, relative-position tables, norms and biases; finite -1e4 mask |
+| `gliner25_decide_fp16hw.tflite` | 1026 MB | wfp16's storage (float16 FULLY_CONNECTED weights behind DEQUANTIZE) over the FP16-hardware graph: LayerNorm power-of-two pre-scale (x*2^-k, eps*4^-k, k from the corpus' FP32 ranges), first feed-forward FULLY_CONNECTED split in two halves, finite -1e4 mask |
+| `gliner25_decide_embeddings_f16.bin` | 262 MB | float16 [128011, 1024], little-endian, row-major |
+
+## Use
+
+Tokenize with `tokenizer.json` and pack the prompt exactly as gliner2 2.0.0 does. Pick the smallest signature that holds the ids
+(refuse more than 512), zero-pad the ids, look each one up in the table (row `id` at byte `id * 2048`) and upcast to float32 into
+`inputs_embeds` [1, N, 1024]; `attention_mask` [1, N] is 1.0 for tokens and 0.0 for padding. `logits` [1, N] holds the classifier
+at every position: read each task's `[L]` marker positions and take a softmax over them (sigmoid for multi-label tasks).
+
+LiteRT `CompiledModel`: on the GPU set the precision explicitly (FP32 for `wfp16`) and constant tensor sharing; on the CPU set
+XNNPACK's weight cache path, or XNNPACK packs a copy of the weights for every signature.
+
+## Validation (Mac, not a phone)
+
+616 Decide calls (2,338 decisions) recorded from the gliner2 2.0.0 library on a synthetic English corpus of short
+conversational statements, packed by the library's collator, padded to the smallest
+bucket and decoded by a Python mirror of an on-device host. ai-edge-litert 2.2.0 on arm64 Mac (Apple M5 Max, macOS 27.0.1):
+the CPU, and the Mac's GPU through the same ML Drift accelerator the phone uses (Metal here, OpenCL on Android) as a check of
+the precision modes. These timings are Mac measurements, not phone numbers.
+
+| Variant | Runtime | Labels as the library | Max probability drift | Mac ms per call p50 by bucket | Gate |
+|---|---|---|---|---|---|
+| `wfp16` | CPU (XNNPACK, 4 threads) | 2338/2338 (100.00%) | 0.00032 | 128: 58.3, 160: 68.1, 512: 248.6 | pass |
+| `wfp16` | Mac GPU (Metal, ML Drift), FP32 precision | 2338/2338 (100.00%) | 0.00032 | 128: 21.0, 160: 23.8, 512: 76.1 | pass |
+| `wfp16` | Mac GPU (Metal, ML Drift), default precision (FP16) | 2226/2338 (95.21%) | 0.30555 | 128: 16.3, 160: 20.5, 512: 49.6 | fail |
+| `fp16hw` | CPU (XNNPACK, 4 threads) | 2338/2338 (100.00%) | 0.00032 | 128: 60.2, 160: 70.5, 512: 255.1 | pass |
+| `fp16hw` | Mac GPU (Metal, ML Drift), FP32 precision | 2338/2338 (100.00%) | 0.00032 | 128: 22.1, 160: 25.7, 512: 79.8 | pass |
+| `fp16hw` | Mac GPU (Metal, ML Drift), default precision (FP16) | 2332/2338 (99.74%) | 0.01158 | 128: 16.6, 160: 22.1, 512: 50.7 | pass |
+
+The acceptance gate: label agreement ≥ 95 %, largest probability drift ≤ 0.05. `validation.json` holds every number.
+
+## On a phone (Galaxy Z Fold 8, 2026-10-28/29)
+
+Snapdragon 8 Elite Gen 5 (SM8850), Adreno 840, Android 17, LiteRT 2.2.0. One request per signature from the
+test set, warm, on a rested phone (it throttles within minutes of continuous runs):
+
+| Setting | s128 | s160 | s512 | RAM taken | Labels as the library |
+|---|---|---|---|---|---|
+| `fp16hw`, GPU FP16 | 62 ms | 81 ms | 439 ms | about 1.0 GB | 9 / 9 |
+| `fp16hw`, GPU FP16 with FP32 accumulation | 80 ms | 99 ms | 496 ms | about 1.05 GB | 9 / 9 |
+| `wfp16`, GPU FP32 | 136 ms | 173 ms | 758 ms | about 1.9 GB | 9 / 9 |
+| `wfp16`, CPU (4 threads, XNNPACK weight cache) | 120 ms | 155 ms | 972 ms | about 0.4–0.5 GB, plus droppable file pages | 9 / 9 |
+
+- **Set constant tensor sharing on the GPU.** Without it each signature holds its own copy of the weights: 5.3 GB of graphics memory against 1.9 GB. The "graphics" figure in PSS counts the weights twice; the RAM the system loses is about 1.0 GB.
+- **Use LOW GPU priority in a rendering app.** At the default, NORMAL or HIGH priority, each 512-token call held the app's renderer off the GPU for about 400 ms. LOW costs no frames but adds about 95–130 ms to every call.
+- **The first load is the slowest.** It takes 6–8 s on the GPU. The program cache shortens later loads very little.
+- **These are LiteRT 2.2.0's numbers.** On LiteRT 2.3.2 the GPU at LOW priority is slower on the same phone: 472 ms a call at s160 (2026-10-30; about 176 ms on 2.2.0) and 2.75 s at s512 (2026-11-01).
+
+## Qualcomm NPU (`npu/`)
+
+Files for the Hexagon NPU of Snapdragon phones, through LiteRT's Qualcomm accelerator: LiteRT 2.3.2 with
+`litert-npu-runtime-qualcomm` 2.3.2 and Qualcomm's `qnn-runtime` 2.50.0 (Qualcomm's AI Stack License). They are not part
+of the GPU and CPU files above. Every one comes from `gliner25_decide_fp16hw.tflite`, because the NPU computes at FP16.
+Inputs, outputs and host steps are the same as above; `npu/manifest.json` lists each file with its chip, signatures,
+size, SHA-256 and the versions it was built with.
+
+| Files | What they are |
+|---|---|
+| `npu/gliner25_decide_fp16hw_s128.tflite`, `_s160`, `_s256` (660 MB / 673 MB / 710 MB) | One signature each, cut from `fp16hw` (on LiteRT's CPU their logits equal the full file's). The phone compiles them for its own NPU at first use, so they serve any Snapdragon LiteRT supports: about 20 / 45 / 130 s on an SM8850, once per OS build. s512 is left out: compiling it on a phone ran out of memory on a Galaxy S26 (litert-community). |
+| `npu/qualcomm/gliner25_decide_fp16hw_<chip>.tflite` | Precompiled on x86-64 Linux (ai-edge-litert 2.3.0, QAIRT 2.50.0.260828): all four signatures over one copy of the weights (`qualcomm_enable_weight_sharing=true`, the compiler's default O3). Each signature runs all 1,846 operations in one NPU partition, so nothing in the file falls back to the GPU or the CPU. The phone loads it without compiling. It runs only on its chip (`Build.SOC_MODEL`) and only with the runtime versions above. Building one takes 13–18 minutes and up to 24 GB of memory on the Linux host. |
+
+| Chip | Snapdragon | Hexagon | Precompiled file | Size | Run on |
+|---|---|---|---|---|---|
+| SM8850 | 8 Elite Gen 5 | V81 | `npu/qualcomm/gliner25_decide_fp16hw_SM8850.tflite` | 877 MB | Galaxy Z Fold 8, 2026-11-01 |
+| SM8750 | 8 Elite | V79 | `npu/qualcomm/gliner25_decide_fp16hw_SM8750.tflite` | 875 MB | compiled, not run on a phone yet |
+| SM8650 | 8 Gen 3 | V75 | `npu/qualcomm/gliner25_decide_fp16hw_SM8650.tflite` | 860 MB | compiled, not run on a phone yet |
+| SM8550 | 8 Gen 2 | V73 | `npu/qualcomm/gliner25_decide_fp16hw_SM8550.tflite` | 862 MB | Galaxy S23 Ultra, 2026-11-02 |
+| SM8450 | 8 Gen 1 | V69 | `npu/qualcomm/gliner25_decide_fp16hw_SM8450.tflite` | 856 MB | compiled, not run on a phone yet |
+
+### On a Galaxy Z Fold 8 (SM8850, 2026-11-01)
+
+LiteRT 2.3.2 with `qnn-runtime` 2.50.0, Android 17. Each file ran the test requests that fit its signature, 10 calls
+each, after a 60 s rest (thermal status 0 before and after). "Run" is the model alone, without the host's table lookup.
+
+| File | Load | Run p50 | Largest logit difference from PyTorch FP32 | Labels as the library |
+|---|---|---|---|---|
+| `npu/qualcomm/gliner25_decide_fp16hw_SM8850.tflite` at s160 | 1.5 s | 31.4 ms | 0.0032 | 12 / 12 |
+| `npu/qualcomm/gliner25_decide_fp16hw_SM8850.tflite` at s512 | 1.8 s | 644 ms | 0.015 | 16 / 16 |
+| the cuts, compiled on the phone: s128 / s160 / s256 | 0.45–0.72 s once compiled | 21.3 / 30.0 / 87.6 ms | 0.0032 / 0.0032 / 0.0029 | 4 / 4, 12 / 12, 12 / 12 |
+| the cuts, each precompiled on Linux for SM8850 | 0.65–0.77 s | 22.4 / 29.9 / 86.8 ms | 0.0032 / 0.0032 / 0.0029 | 4 / 4, 12 / 12, 12 / 12 |
+
+- **Precompiled files run like the phone's own compile,** within about 1 ms, with the same logits, and skip the compile.
+- **s512 on the NPU:** the four-signature file holds 52 MB of dirty memory and 859 MB of file pages there. On the same
+  phone and LiteRT version the GPU path (`fp16hw`, FP16, LOW priority) took 2.75 s a call at s512, 24 s to load and
+  2.0 GB of dirty memory.
+- s128 and s256 from the four-signature file have not been run yet. From a three-signature file built the same way
+  (s128 to s256, 755 MB) they ran at 21.8 and 88.3 ms.
+
+### On a Galaxy S23 Ultra (SM8550, 2026-11-02)
+
+LiteRT 2.3.2 with `qnn-runtime` 2.50.0, Android 16, 8 GB of memory. The same method as on the Fold. For the GPU rows the
+"Run" column is the whole call, because the GPU runs asynchronously.
+
+| File | Load | Run p50 | Largest logit difference from PyTorch FP32 | Labels as the library |
+|---|---|---|---|---|
+| `npu/qualcomm/gliner25_decide_fp16hw_SM8550.tflite` at s128 / s160 / s256 | 1.5–1.6 s | 32.2 / 53.9 / 170 ms | 0.0039 / 0.0042 / 0.0042 | 4 / 4, 12 / 12, 12 / 12 |
+| `npu/qualcomm/gliner25_decide_fp16hw_SM8550.tflite` at s512 | 1.7 s | 1,149 ms | 0.014 | 16 / 16 |
+| the cuts, compiled on the phone: s128 / s160 / s256 | 21 / 41 / 117 s to compile | 31.3 / 53.2 / 164 ms | 0.0039 / 0.0042 / 0.0042 | 4 / 4, 12 / 12, 12 / 12 |
+| the cuts, each precompiled on Linux for SM8550 | 0.5–0.65 s | 32.0 / 53.9 / 162 ms | 0.0039 / 0.0042 / 0.0042 | 4 / 4, 12 / 12, 12 / 12 |
+| `fp16hw` on the GPU (FP16, LOW priority), s160 / s512 | 6.3 / 7.7 s | 369 / 2,099 ms | 0.019 / 0.053 | 12 / 12, 16 / 16 |
+
+- **Precompiled files run like the phone's own compile** here too, with the same logits.
+- **Memory:** the four-signature file holds 50–69 MB of dirty memory and 853 MB of file pages. The GPU held 1.4 GB (s160)
+  and 2.0 GB (s512) of dirty memory. A compile on the phone holds about 1.3 GB of dirty memory in the process that
+  compiles; reloaded from LiteRT's compiler cache, the model holds about 50 MB, like a precompiled file.
+- **s512:** 1.17 s a call on the NPU against 2.10 s on the GPU.
+
+## Compared with litert-community/GLiNER2.5-Decide-LiteRT
+
+| | this conversion | litert-community (rev c687e899) |
+|---|---|---|
+| Files | one `.tflite` with signatures s128 / s160 / s256 / s512 over one set of weights (1.03 GB), plus the 262 MB table | one file per length: s128 / s256 / s512, 2.18 GB together, plus the table |
+| Lengths | adds s160: requests of 129 to 160 tokens no longer pad to 256 | 128 / 256 / 512 |
+| Output | `logits` at every position (the host reads the `[L]` markers, as smdesai's Core ML port does) | `label_routing` input, 32 label logits out |
+| Validation | every recorded library call (616 calls, 2,338 decisions): wfp16 2,338 / 2,338; fp16hw at GPU FP16 2,332 / 2,338 | 42 decisions |
+| GPU speed on SM8850 | s128 62 ms at FP16 (Fold 8) | s128 60 ms with FP32 accumulation (S26) |
+
+## Files
+
+`LICENSE` (Apache-2.0), `NOTICE.txt` (attribution and changes), `model-card.md` (the original card), `config.json`
+(contract), `validation.json`, `SHA256SUMS`, tokenizer files, `source/` (the checkpoint's configs), and `npu/` (the Qualcomm NPU files above).

SHA256SUMS

@@ -0,0 +1,23 @@
+cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  LICENSE
+0a8689579d9a76e8b3b1c6769e7293d7ad0672394545f7fab94c24eb167a96a0  NOTICE.txt
+3a835c128e6eec1f68b7dd4a458403347a83991034eb69b93c12b99fd693d69e  README.md
+b3595e87167c626611cb102d066bda3a07af7c521520a1e4ee04d52db33ab5f2  config.json
+f90f5d837721b3d4df7194a89ea18bbea5c449e6944fb6078664f1a8d20484fd  gliner25_decide_embeddings_f16.bin
+b5567c71caddf9ce476e242c8778622375a8b2c415cf078248f75b092452b605  gliner25_decide_fp16hw.tflite
+eed09fce5c62a0629f4cc192b97401a5a11b01571a63b1e64829b5011668a52c  gliner25_decide_wfp16.tflite
+ce29834da27c7ddacc74e5ebb560c9104e1b83d04a8ba8dd82059737e9dbd419  model-card.md
+323e3f48ad74ba4110f69c58d40d8e2f55e5f1b9723cfb82c30c2a622be86f7a  npu/gliner25_decide_fp16hw_s128.tflite
+1783d73131c2395c3e39e6364536e2f9643b4c1eba3051db21b4cd91a868e0ed  npu/gliner25_decide_fp16hw_s160.tflite
+08fbd3820bace55861948c392a130ab934895d2d75a54e7e1666aabdf0ba16e1  npu/gliner25_decide_fp16hw_s256.tflite
+b31f074d8dbf701eaa0a4d2597eb70edba2f6bd60d3537733c5c997c2ba099a2  npu/manifest.json
+b82f3b26b9cd9ce59ea1340486e81bec51a4aae6fcb7b5ff7769b717326dc32a  npu/qualcomm/gliner25_decide_fp16hw_SM8450.tflite
+86bfd5ca3aea9075dcb0482c04572dcfd247f2f6f3bb040ac0d989d8e60ed6bd  npu/qualcomm/gliner25_decide_fp16hw_SM8550.tflite
+48a382ae593afe724eb40b833991b5c8fb8dbb2bb6b14c74ebf9abb862177e02  npu/qualcomm/gliner25_decide_fp16hw_SM8650.tflite
+5357988607b7287eedcbd7328f1db3ed91ed34afc4bce3f8042ae47c5a5b32df  npu/qualcomm/gliner25_decide_fp16hw_SM8750.tflite
+84e72594a330efdb86e09e4319e30f02ed75f63917fc55346ed47351ca1b30c6  npu/qualcomm/gliner25_decide_fp16hw_SM8850.tflite
+e748e5b80575471c91b3f0dd00f513ba58242544fcb7e1236e0021e61abd7673  source/config.json
+bd32f1484ba5a199f7a63df44df3814b839fffcf6e64478323c4689868ef6015  source/encoder_config/config.json
+84ea70143f533d7e99b393d87f20010887a9ac2cba955828ef313886e4e83f4f  special_tokens_map.json
+3ad87d9ffe669147063e70850927dd2da90249e2acc5c8527f1eb65df467bcc8  tokenizer.json
+323199a4e946039410899f3779f2aa3eaef1500213c512727ad0f623d4f21309  tokenizer_config.json
+61af75058de96a0cce60c500e4d34ba0a6b94c8e4b1950057ac31a558c3fc457  validation.json

config.json

@@ -0,0 +1,380 @@
+{
+ "source": "fastino/GLiNER2.5-Decide@bbe10ff77ebb238777c17d3a8ac9260e30929057",
+ "variant": "wfp16",
+ "precision": "FULLY_CONNECTED weights stored float16 behind DEQUANTIZE (ai-edge-quantizer FLOAT_CASTING); FP32 activations, relative-position tables, norms and biases; finite -1e4 mask",
+ "runtime": {
+  "litert": "2.2.0 (validated on the Mac with ai-edge-litert 2.2.0; com.google.ai.edge.litert:litert:2.2.0 on Android)",
+  "api": "CompiledModel",
+  "converter": {
+   "litert-torch": "0.9.4",
+   "ai-edge-litert": "2.2.0",
+   "ai-edge-quantizer": "0.9.0",
+   "litert-converter": "0.4.0",
+   "torch": "2.13.0",
+   "transformers": "4.57.6",
+   "gliner2": "2.0.0"
+  }
+ },
+ "graphs": [
+  {
+   "path": "gliner25_decide_wfp16.tflite",
+   "variant": "wfp16",
+   "shipped": true,
+   "about": "FULLY_CONNECTED weights stored float16 behind DEQUANTIZE (ai-edge-quantizer FLOAT_CASTING); FP32 activations, relative-position tables, norms and biases; finite -1e4 mask",
+   "bytes": 1026117712,
+   "signatures": [
+    {
+     "key": "s128",
+     "inputs": [
+      {
+       "name": "attention_mask",
+       "dtype": "float32",
+       "shape": [
+        1,
+        128
+       ],
+       "about": "1.0 for the request's tokens, 0.0 for padding"
+      },
+      {
+       "name": "inputs_embeds",
+       "dtype": "float32",
+       "shape": [
+        1,
+        128,
+        1024
+       ],
+       "about": "rows of the float16 token table at the zero-padded ids, upcast to float32 (padding rows are id 0's)"
+      }
+     ],
+     "outputs": [
+      {
+       "name": "logits",
+       "dtype": "float32",
+       "shape": [
+        1,
+        128
+       ],
+       "about": "the classifier at every position"
+      }
+     ]
+    },
+    {
+     "key": "s160",
+     "inputs": [
+      {
+       "name": "attention_mask",
+       "dtype": "float32",
+       "shape": [
+        1,
+        160
+       ],
+       "about": "1.0 for the request's tokens, 0.0 for padding"
+      },
+      {
+       "name": "inputs_embeds",
+       "dtype": "float32",
+       "shape": [
+        1,
+        160,
+        1024
+       ],
+       "about": "rows of the float16 token table at the zero-padded ids, upcast to float32 (padding rows are id 0's)"
+      }
+     ],
+     "outputs": [
+      {
+       "name": "logits",
+       "dtype": "float32",
+       "shape": [
+        1,
+        160
+       ],
+       "about": "the classifier at every position"
+      }
+     ]
+    },
+    {
+     "key": "s256",
+     "inputs": [
+      {
+       "name": "attention_mask",
+       "dtype": "float32",
+       "shape": [
+        1,
+        256
+       ],
+       "about": "1.0 for the request's tokens, 0.0 for padding"
+      },
+      {
+       "name": "inputs_embeds",
+       "dtype": "float32",
+       "shape": [
+        1,
+        256,
+        1024
+       ],
+       "about": "rows of the float16 token table at the zero-padded ids, upcast to float32 (padding rows are id 0's)"
+      }
+     ],
+     "outputs": [
+      {
+       "name": "logits",
+       "dtype": "float32",
+       "shape": [
+        1,
+        256
+       ],
+       "about": "the classifier at every position"
+      }
+     ]
+    },
+    {
+     "key": "s512",
+     "inputs": [
+      {
+       "name": "attention_mask",
+       "dtype": "float32",
+       "shape": [
+        1,
+        512
+       ],
+       "about": "1.0 for the request's tokens, 0.0 for padding"
+      },
+      {
+       "name": "inputs_embeds",
+       "dtype": "float32",
+       "shape": [
+        1,
+        512,
+        1024
+       ],
+       "about": "rows of the float16 token table at the zero-padded ids, upcast to float32 (padding rows are id 0's)"
+      }
+     ],
+     "outputs": [
+      {
+       "name": "logits",
+       "dtype": "float32",
+       "shape": [
+        1,
+        512
+       ],
+       "about": "the classifier at every position"
+      }
+     ]
+    }
+   ],
+   "use": "GPU with explicit FP32 precision (litert-community: the default GPU precision changed 28 of 42 decisions), or the CPU"
+  },
+  {
+   "path": "gliner25_decide_fp16hw.tflite",
+   "variant": "fp16hw",
+   "shipped": false,
+   "about": "wfp16's storage (float16 FULLY_CONNECTED weights behind DEQUANTIZE) over the FP16-hardware graph: LayerNorm power-of-two pre-scale (x*2^-k, eps*4^-k, k from the corpus' FP32 ranges), first feed-forward FULLY_CONNECTED split in two halves, finite -1e4 mask",
+   "bytes": 1026073648,
+   "signatures": [
+    {
+     "key": "s128",
+     "inputs": [
+      {
+       "name": "attention_mask",
+       "dtype": "float32",
+       "shape": [
+        1,
+        128
+       ],
+       "about": "1.0 for the request's tokens, 0.0 for padding"
+      },
+      {
+       "name": "inputs_embeds",
+       "dtype": "float32",
+       "shape": [
+        1,
+        128,
+        1024
+       ],
+       "about": "rows of the float16 token table at the zero-padded ids, upcast to float32 (padding rows are id 0's)"
+      }
+     ],
+     "outputs": [
+      {
+       "name": "logits",
+       "dtype": "float32",
+       "shape": [
+        1,
+        128
+       ],
+       "about": "the classifier at every position"
+      }
+     ]
+    },
+    {
+     "key": "s160",
+     "inputs": [
+      {
+       "name": "attention_mask",
+       "dtype": "float32",
+       "shape": [
+        1,
+        160
+       ],
+       "about": "1.0 for the request's tokens, 0.0 for padding"
+      },
+      {
+       "name": "inputs_embeds",
+       "dtype": "float32",
+       "shape": [
+        1,
+        160,
+        1024
+       ],
+       "about": "rows of the float16 token table at the zero-padded ids, upcast to float32 (padding rows are id 0's)"
+      }
+     ],
+     "outputs": [
+      {
+       "name": "logits",
+       "dtype": "float32",
+       "shape": [
+        1,
+        160
+       ],
+       "about": "the classifier at every position"
+      }
+     ]
+    },
+    {
+     "key": "s256",
+     "inputs": [
+      {
+       "name": "attention_mask",
+       "dtype": "float32",
+       "shape": [
+        1,
+        256
+       ],
+       "about": "1.0 for the request's tokens, 0.0 for padding"
+      },
+      {
+       "name": "inputs_embeds",
+       "dtype": "float32",
+       "shape": [
+        1,
+        256,
+        1024
+       ],
+       "about": "rows of the float16 token table at the zero-padded ids, upcast to float32 (padding rows are id 0's)"
+      }
+     ],
+     "outputs": [
+      {
+       "name": "logits",
+       "dtype": "float32",
+       "shape": [
+        1,
+        256
+       ],
+       "about": "the classifier at every position"
+      }
+     ]
+    },
+    {
+     "key": "s512",
+     "inputs": [
+      {
+       "name": "attention_mask",
+       "dtype": "float32",
+       "shape": [
+        1,
+        512
+       ],
+       "about": "1.0 for the request's tokens, 0.0 for padding"
+      },
+      {
+       "name": "inputs_embeds",
+       "dtype": "float32",
+       "shape": [
+        1,
+        512,
+        1024
+       ],
+       "about": "rows of the float16 token table at the zero-padded ids, upcast to float32 (padding rows are id 0's)"
+      }
+     ],
+     "outputs": [
+      {
+       "name": "logits",
+       "dtype": "float32",
+       "shape": [
+        1,
+        512
+       ],
+       "about": "the classifier at every position"
+      }
+     ]
+    }
+   ],
+   "use": "GPU at FP16 precision, or the Qualcomm NPU (FP16 compute); the FP32 paths give the same decisions as wfp16 (the rewrites are exact in FP32)"
+  }
+ ],
+ "table": {
+  "path": "gliner25_decide_embeddings_f16.bin",
+  "dtype": "float16",
+  "byteOrder": "little-endian",
+  "shape": [
+   128011,
+   1024
+  ],
+  "layout": "row-major, no header: row `id` is bytes [id * 2048, id * 2048 + 2048), 1024 float16 values",
+  "bytes": 262166528,
+  "sha256": "f90f5d837721b3d4df7194a89ea18bbea5c449e6944fb6078664f1a8d20484fd",
+  "use": "memory-map the file; for each position of the bucket take the row of its zero-padded id (padding takes id 0's row) and upcast to float32 into inputs_embeds"
+ },
+ "buckets": [
+  128,
+  160,
+  256,
+  512
+ ],
+ "host": {
+  "bucket": "the smallest of s128 / s160 / s256 / s512 that holds the request's ids; refuse longer than 512 tokens, never truncate",
+  "inputs": "inputs_embeds float32 [1, N, 1024] and attention_mask float32 [1, N] (1.0 for tokens, 0.0 for padding); bind them by name: the flatbuffer's SignatureDef lists attention_mask, inputs_embeds, while ai-edge-litert 2.2.0's CompiledModel reports inputs_embeds, attention_mask",
+  "outputs": "logits float32 [1, N]: read the [L] marker positions of each task (single-label: softmax over the task's markers; multi-label: sigmoid), as smdesai's Core ML port (GLiNER25-Decide-FP16-CoreML) does with its logits",
+  "temperature": 1.0
+ },
+ "accelerators": {
+  "gpu": "set GpuOptions precision explicitly (FP32 for wfp16; FP16 only with fp16hw) and constantTensorSharing, so the signatures share the weights on the GPU as they do in the file",
+  "cpu": "set CpuOptions' XNNPACK weight cache path: without it XNNPACK packs a copy of the weights for every signature (Mac, wfp16: see validation.json memory); 4 threads in the validation",
+  "npu": "fp16hw only (FP16 compute); not run on the Mac"
+ },
+ "positionTables": "each signature holds its own FP32 copy of the relative-position tables (the converter folds each bucket's slice; 24 layers x 2 x [1, 16, 64, 2N]); every other constant is stored once and shared by all signatures",
+ "coremlDifferences": [
+  "a signature per bucket (s128, s160, s256, s512) instead of the multifunction package's context128/context256/context512",
+  "the token table lives outside the graph (inputs_embeds), as litert-community's port does; the Core ML port takes input_ids",
+  "attention_mask is float32 instead of int32; logits are the same [1, N] float32 at every position",
+  "precision: FULLY_CONNECTED weights stored float16 behind DEQUANTIZE (ai-edge-quantizer FLOAT_CASTING); FP32 activations, relative-position tables, norms and biases; finite -1e4 mask (the Core ML port runs FP16 on the GPU)"
+ ],
+ "tokenizer": {
+  "file": "tokenizer.json",
+  "specialTokens": {
+   "[PAD]": 0,
+   "[CLS]": 1,
+   "[SEP]": 2,
+   "[UNK]": 3,
+   "[MASK]": 128000,
+   "[SEP_STRUCT]": 128001,
+   "[SEP_TEXT]": 128002,
+   "[P]": 128003,
+   "[C]": 128004,
+   "[E]": 128005,
+   "[R]": 128006,
+   "[L]": 128007,
+   "[EXAMPLE]": 128008,
+   "[OUTPUT]": 128009,
+   "[DESCRIPTION]": 128010
+  }
+ },
+ "provenance": {
+  "graph": "ported from litert-community/GLiNER2.5-Decide-LiteRT@c687e899 (Apache-2.0)"
+ }
+}

gliner25_decide_embeddings_f16.bin

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

gliner25_decide_fp16hw.tflite

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

gliner25_decide_wfp16.tflite

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

model-card.md

@@ -0,0 +1,501 @@
+---
+library_name: gliner2
+license: apache-2.0
+language:
+- en
+pipeline_tag: token-classification
+tags:
+- gliner2
+- Text classification
+- Intent classification
+- Sentiment Analysis
+- Topic classification
+- Named Entity Recognition
+base_model: fastino/gliner2-large-v1
+---
+<div align="center">
+  <a href="https://fastino.ai/lp/gliner?utm_source=huggingface" target="_blank" rel="noopener noreferrer">
+    <img src="GLiNER-2.5-Decision-HF-Banner.png" alt="Fastino Agent - Fine-tune GLiNER with a single prompt" width="100%"/>
+  </a>
+</div>
+
+<div style="display: flex; flex-wrap: wrap; gap: 8px; margin-bottom: 16px;">
+  <a href="https://agent.fastino.ai" target="_blank" rel="noreferrer" style="text-decoration:none;">
+    <img src="https://img.shields.io/badge/Finetune-GLiNER2.5-EA4335" alt="Fine-tune and Deploy GLiNER2.5 with Fastino Agent" style="vertical-align:middle;">
+  </a>
+  <a href="https://arxiv.org/abs/2507.18546" target="_blank" rel="noreferrer" style="text-decoration:none;">
+    <img src="https://img.shields.io/badge/arXiv-2507.18546-b31b1b.svg?logo=arxiv" alt="arXiv Paper" style="vertical-align:middle;">
+  </a>
+  <a href="https://github.com/fastino-ai/GLiNER2" target="_blank" rel="noreferrer" style="text-decoration:none;">
+    <img src="https://img.shields.io/badge/GitHub-GLiNER2-black?logo=github" alt="GitHub" style="vertical-align:middle;">
+  </a>
+  <a href="https://x.com/fastinoAI" target="_blank" rel="noreferrer" style="text-decoration:none;">
+    <img src="https://img.shields.io/twitter/follow/:fastinoAI" alt="Follow @fastinoAI" style="vertical-align:middle;">
+  </a>
+</div>
+
+# GLiNER2.5-Decide
+
+**The classification model in the GLiNER2.5 family.** One 340M checkpoint, any label set you pass at call time: intent, routing, sentiment, priority, policy, and multi-label tags, in a single forward pass. No prompt template. No generated tokens. Load it with `AutoExtractor` and ship it locally.
+
+On a 17-domain held-out suite it leads open typed-decision models, including a 1B GLiNER2 and a 4B generative baseline. A single call can score several heads at once. Single-label tasks return one string. Multi-label tasks return every label above the threshold.
+
+This release is not a general-purpose model. It does not reason, explain, or answer open questions. It was not trained on public benchmarks. It is a specialist for operational decisions: customer and banking intent, travel and clinic requests, review sentiment, document type, email and ticket routing, human handoff, agent completion, moderation, severity, urgency, and spam. The same call also answers a question about a passage, classifies a book, uses labels that carry a description, and scores an ordinal scale.
+
+Outputs below are potential results for these inputs. They show the shape `classify_text` returns.
+
+## Install
+
+```bash
+pip install gliner2
+```
+
+```python
+from gliner2 import AutoExtractor
+
+model = AutoExtractor.from_pretrained("fastino/GLiNER2.5-Decide")
+```
+
+## Examples
+
+### Customer support intent
+
+Route a live message before a human ever sees it. Refunds, cancellations, login failures, and shipping delays share one inbox and one label set. Decide picks the action the queue should take, so the right workflow starts on the first turn.
+
+```python
+model.classify_text(
+    "My subscription renewed on April 15 for ¥5,400 after the service was already down. Can I get that charge refunded?",
+    {"intent": [
+        "order_status", "refund_request", "cancel_subscription", "update_payment",
+        "login_problem", "shipping_delay", "bug_report", "speak_to_human", "other",
+    ]},
+)
+```
+
+Potential output:
+
+```text
+{"intent": "refund_request"}
+```
+
+### Banking request
+
+A single customer message often mixes a failed payment, a beneficiary change, and a fee question. The label set is the product catalog: transfers, cards, fraud, mortgages. The model maps the utterance onto the operation the core system should open.
+
+```python
+model.classify_text(
+    "The transfer I sent this morning is still pending, and I think I used the wrong sort code. Can you stop it and add Emily as the beneficiary instead?",
+    {"intent": [
+        "transfer_pending", "transfer_cancel", "beneficiary_add", "card_lost",
+        "balance_inquiry", "fraud_report", "mortgage_application", "fee_explanation",
+    ]},
+)
+```
+
+Potential output:
+
+```text
+{"intent": "transfer_cancel"}
+```
+
+### Travel request
+
+Booking, changing, cancelling, and seat requests look similar in free text and trigger different inventory calls. Use this when a chat or email has to become a structured booking action without a form.
+
+```python
+model.classify_text(
+    "I need to move my Friday flight to Paris to Saturday morning, same cabin, and keep the aisle seat if you can.",
+    {"request": ["book", "change", "cancel", "status", "seat_change", "refund", "baggage"]},
+)
+```
+
+Potential output:
+
+```text
+{"request": "change"}
+```
+
+### Clinic request
+
+Patients describe symptoms and the thing they want in the same sentence: an appointment, a refill, a result, a referral. Front-desk routing needs that distinction before anyone is put on a schedule.
+
+```python
+model.classify_text(
+    "The rash came back after the antibiotics finished. Can I get a same-week appointment with dermatology, or should I just refill the cream?",
+    {"request": [
+        "book_appointment", "refill_prescription", "test_results",
+        "referral", "billing_question", "cancel_appointment",
+    ]},
+)
+```
+
+Potential output:
+
+```text
+{"request": "book_appointment"}
+```
+
+### Review sentiment
+
+Star ratings hide mixed reviews. A product can be praised and rejected in one paragraph. A four-way sentiment label is what a dashboard, a reply policy, or a ranking feature actually needs.
+
+```python
+model.classify_text(
+    "Battery dies before lunch, but the keyboard and the screen are the best I have used on a laptop.",
+    {"sentiment": ["positive", "negative", "mixed", "neutral"]},
+)
+```
+
+Potential output:
+
+```text
+{"sentiment": "mixed"}
+```
+
+### Product aspects
+
+Sentiment says the review is mixed. Aspects say why: battery, keyboard, screen. Several labels apply at once, so this head is multi-label. That is the input to aspect-level analytics and to a reply that mentions the right part of the product.
+
+```python
+model.classify_text(
+    "Battery dies before lunch, but the keyboard and the screen are the best I have used on a laptop.",
+    {"aspects": {
+        "labels": ["battery", "keyboard", "screen", "camera", "price", "support"],
+        "multi_label": True,
+        "cls_threshold": 0.4,
+    }},
+)
+```
+
+Potential output:
+
+```text
+{"aspects": ["battery", "keyboard", "screen"]}
+```
+
+### News topic
+
+Wire copy, alerts, and scraped headlines have to land in a section before they are ranked or summarized. The label set is the section list of the product, not a fixed taxonomy baked into the model.
+
+```python
+model.classify_text(
+    "The central bank held rates and said inflation is still above target, pushing bank stocks lower in afternoon trading.",
+    {"topic": ["politics", "business", "sports", "science", "entertainment", "world"]},
+)
+```
+
+Potential output:
+
+```text
+{"topic": "business"}
+```
+
+### Document type
+
+Inboxes and shared drives mix invoices, contracts, resumes, and notes. Classifying the document is the gate in front of extraction: an invoice goes to payables, a contract goes to review, a resume goes to screening.
+
+```python
+model.classify_text(
+    "INVOICE 1842\nBill to: Northstar QA\nAmount due: 2,400 USD\nDue: 30 April 2026\nWire instructions are on page 2.",
+    {"document_type": ["invoice", "receipt", "contract", "resume", "support_email", "meeting_notes"]},
+)
+```
+
+Potential output:
+
+```text
+{"document_type": "invoice"}
+```
+
+### Email triage
+
+A shared mailbox needs three answers before a message is filed: what the sender wants, how soon it matters, and which team owns it. One call scores all three heads on the same text, so the router does not run the model three times.
+
+```python
+model.classify_text(
+    "From: compliance@group.example\nSubject: Protocol update — action required today\n\nPlease confirm the new retention rule is applied before Friday's audit.",
+    {
+        "intent": ["fyi", "request", "approval", "complaint", "newsletter", "security_alert"],
+        "urgency": ["low", "normal", "high", "critical"],
+        "route": ["support", "billing", "legal", "security", "finance", "archive"],
+    },
+)
+```
+
+Potential output:
+
+```text
+{"intent": "request", "urgency": "high", "route": "legal"}
+```
+
+### Ticket routing
+
+Employees describe a problem, not a department. Payroll, benefits, IT access, and facilities share the same portal. The queue label is the assignment, so the ticket opens in the right team instead of bouncing through a dispatcher.
+
+```python
+model.classify_text(
+    "[subject] 401k deduction missing from this paystub\n[body] Last month's contribution posted. This month the line is gone and HR told me to open a ticket.",
+    {"queue": [
+        "payroll", "benefits", "it_access", "facilities",
+        "expense_reimbursement", "manager_approval",
+    ]},
+)
+```
+
+Potential output:
+
+```text
+{"queue": "benefits"}
+```
+
+### Handoff to a person
+
+Most turns should stay automated. A repeated complaint, an explicit request for a human, or a case the bot cannot close should leave the flow. This is the yes/no gate in front of an agent queue.
+
+```python
+model.classify_text(
+    "This is the third time I have explained the same missing refund. Stop the bot and get me a person.",
+    {"handoff": ["yes", "no"]},
+)
+```
+
+Potential output:
+
+```text
+{"handoff": "yes"}
+```
+
+### Did the agent finish?
+
+A trace can look busy and still be incomplete: a draft saved, a button disabled, a required field empty. Supervisors and eval harnesses need a finish decision from the goal plus the last state, not from whether the model stopped talking.
+
+```python
+model.classify_text(
+    "Goal: email the Q4 summary to every partner.\nLast action: draft saved in the hub.\nSend button is still disabled because two partners have no address.",
+    {"finished": ["yes", "no"]},
+)
+```
+
+Potential output:
+
+```text
+{"finished": "no"}
+```
+
+### Moderation
+
+User content and model output both need a policy decision before they are shown or acted on. The labels are the policy, from allow through personal data, harassment, scam, and spam, so a filter can block, redact, or escalate.
+
+```python
+model.classify_text(
+    "Post the customer's home address in the public thread so everyone can see where the package actually went.",
+    {"policy": ["allow", "personal_data", "harassment", "scam", "violence", "spam"]},
+)
+```
+
+Potential output:
+
+```text
+{"policy": "personal_data"}
+```
+
+### Incident severity
+
+Pages and deploys produce more notes than pages. Severity is what decides whether this wakes someone up. Staging-only tag drift is not a production checkout failure, and the label should say so.
+
+```python
+model.classify_text(
+    "The deploy left resource tags inconsistent across staging. Production checkout is unaffected. No customer reports yet.",
+    {"severity": ["info", "low", "medium", "high", "critical"]},
+)
+```
+
+Potential output:
+
+```text
+{"severity": "low"}
+```
+
+### Urgency score
+
+Some queues want a rank, not a bucket. Pass `"0"` through `"5"` as ordinary strings. A payroll cutoff before 5pm and a typo in a wiki page should not receive the same score, and the label is what the SLA system reads.
+
+```python
+model.classify_text(
+    "Payroll file has to be corrected before the 5pm cutoff or the whole company is paid late.",
+    {"urgency": ["0", "1", "2", "3", "4", "5"]},
+)
+```
+
+Potential output:
+
+```text
+{"urgency": "5"}
+```
+
+### Spam or not
+
+The first filter on an inbox or a comment stream. Phishing and mailbox-full lures should never reach the intent router. A two-label decision keeps that check cheap enough to run on every message.
+
+```python
+model.classify_text(
+    "Your mailbox is almost full. Click here in the next hour or we will delete every message.",
+    {"label": ["spam", "ham"]},
+)
+```
+
+Potential output:
+
+```text
+{"label": "spam"}
+```
+
+### Several decisions at once
+
+Real requests carry more than one fact. A guest can need a room move, a billing release, and a maintenance ticket in the same call. Intent, priority, a human gate, and multi-label topics are scored together, which is how a property system opens the right work orders without a chain of prompts.
+
+```python
+model.classify_text(
+    "Guest in room 1408 says the AC has been out since yesterday and they want to move tonight or leave. They also asked for the incidentals hold to be released.",
+    {
+        "intent": ["maintenance", "room_change", "checkout", "billing", "complaint", "amenity_request"],
+        "priority": ["low", "normal", "high", "urgent"],
+        "needs_human": ["yes", "no"],
+        "topics": {
+            "labels": ["hvac", "billing", "housekeeping", "noise", "safety"],
+            "multi_label": True,
+            "cls_threshold": 0.4,
+        },
+    },
+)
+```
+
+Potential output:
+
+```text
+{
+  "intent": "room_change",
+  "priority": "high",
+  "needs_human": "yes",
+  "topics": ["hvac", "billing"]
+}
+```
+
+### Question over a passage
+
+The text is the source. The question is the task. Yes or no is the whole answer: no chain of thought, no extracted sentence, just the decision a checker or a form needs.
+
+```python
+model.classify_text(
+    "The treaty was signed in Paris in 1992. It entered into force the following year, after the last signatory ratified it.",
+    {"answer": {
+        "labels": ["yes", "no"],
+        "prompt": "Did the treaty enter into force in 1992?",
+    }},
+)
+```
+
+Potential output:
+
+```text
+{"answer": "no"}
+```
+
+### Book
+
+A catalog, a slush pile, or a library inbox needs a genre before anyone writes a blurb. The passage is enough. The label set is the shelf list.
+
+```python
+model.classify_text(
+    "She closed the ledger, blew out the lamp, and listened for the stair. The house had been empty since the winter the river took the bridge.",
+    {"genre": ["mystery", "romance", "history", "science_fiction", "literary_fiction", "cookbook"]},
+)
+```
+
+Potential output:
+
+```text
+{"genre": "literary_fiction"}
+```
+
+### Labels with a description
+
+When the name of a label is not enough, pass a short description with it. The description is part of the decision, which is how a private taxonomy stays precise without a bigger model.
+
+```python
+model.classify_text(
+    "Please reset the card PIN. The new one never arrived and the old one is locked after three tries.",
+    {"intent": {
+        "labels": {
+            "card_pin_change": "The customer wants a new PIN or the current PIN replaced",
+            "card_lost": "The physical card is missing",
+            "balance_inquiry": "The customer wants the current balance",
+        },
+    }},
+)
+```
+
+Potential output:
+
+```text
+{"intent": "card_pin_change"}
+```
+
+### Ordinal score
+
+Some products want a rank, not a class. Pass the scale as ordinary strings, from `"0"` to `"10"`. A review, a rubric, or a satisfaction form can read the label directly.
+
+```python
+model.classify_text(
+    "I finished it in two nights. The ending is earned, the middle drags, and I would still hand it to a friend.",
+    {"rating": ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]},
+)
+```
+
+Potential output:
+
+```text
+{"rating": "7"}
+```
+
+## Benchmark
+
+Exact-match accuracy on [`fastino/fast-decisions`](https://huggingface.co/datasets/fastino/fast-decisions): 17 domains, 300 held-out examples each, the same text and the same candidate labels for every model.
+
+| Model | Avg |
+|---|---:|
+| **GLiNER2.5-Decide** | **60.2%** |
+| GLiNER2 XL (1B) | 59.6% |
+| JevK5 | 57.6% |
+| SemIf (Qwen3.5-4B) | 56.4% |
+| GLiFormer large-v1 | 49.0% |
+| Laya Router | 46.6% |
+
+A 340M encoder, ahead of models up to 4B. Domain list and label sets are on the [dataset card](https://huggingface.co/datasets/fastino/fast-decisions).
+
+## Details
+
+- **What it is:** a specialist classifier for operational decisions, including questions over a passage, books, described labels, and ordinal scores
+- **What it is not:** a general-purpose model. No reasoning, no explanations, no open-ended answers. Not trained on public benchmarks.
+- **Encoder:** DeBERTa-v3-large
+- **Parameters:** 340M
+- **Runs on:** CPU or GPU, through `gliner2`
+- **License:** Apache 2.0
+
+## Fine-tuning
+
+Decide can be fine-tuned locally with the `gliner2` trainer (see the [training guide](https://github.com/fastino-ai/GLiNER2#-training-custom-models)). The [Fastino API](https://agent.fastino.ai) also offers hosted fine-tuning and serving for GLiNER models, usually faster than training locally. Agents can find the hosted workflow in [`SKILL.md`](SKILL.md).
+
+## Citation
+
+```bibtex
+@misc{zaratiana2025gliner2efficientmultitaskinformation,
+      title={GLiNER2: An Efficient Multi-Task Information Extraction System with Schema-Driven Interface},
+      author={Urchade Zaratiana and Gil Pasternak and Oliver Boyd and George Hurn-Maloney and Ash Lewis},
+      year={2025},
+      eprint={2507.18546},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2507.18546},
+}
+```

npu/gliner25_decide_fp16hw_s128.tflite

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

npu/gliner25_decide_fp16hw_s160.tflite

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

npu/gliner25_decide_fp16hw_s256.tflite

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

npu/manifest.json

@@ -0,0 +1,123 @@
+{
+  "about": "Qualcomm Hexagon NPU files for GLiNER2.5-Decide (README.md, 'Qualcomm NPU'). Every file comes from gliner25_decide_fp16hw.tflite. The cuts compile on the phone; a precompiled file runs only on its chip (Build.SOC_MODEL) and with the runtime versions below. checkedOn is null for files not yet run on a phone.",
+  "source": {
+    "path": "gliner25_decide_fp16hw.tflite",
+    "sha256": "b5567c71caddf9ce476e242c8778622375a8b2c415cf078248f75b092452b605"
+  },
+  "runtime": {
+    "litert": "2.3.2",
+    "litertNpuRuntimeQualcomm": "2.3.2",
+    "qnnRuntime": "2.50.0"
+  },
+  "compiler": {
+    "aiEdgeLitert": "2.3.0",
+    "qairt": "2.50.0.260828",
+    "host": "x86-64 Ubuntu 24.04",
+    "options": {
+      "qualcomm_enable_weight_sharing": true,
+      "qualcomm_optimization_level": "O3 (the default)"
+    }
+  },
+  "cuts": [
+    {
+      "path": "npu/gliner25_decide_fp16hw_s128.tflite",
+      "signature": "s128",
+      "bytes": 660145456,
+      "sha256": "323e3f48ad74ba4110f69c58d40d8e2f55e5f1b9723cfb82c30c2a622be86f7a"
+    },
+    {
+      "path": "npu/gliner25_decide_fp16hw_s160.tflite",
+      "signature": "s160",
+      "bytes": 672733200,
+      "sha256": "1783d73131c2395c3e39e6364536e2f9643b4c1eba3051db21b4cd91a868e0ed"
+    },
+    {
+      "path": "npu/gliner25_decide_fp16hw_s256.tflite",
+      "signature": "s256",
+      "bytes": 710482320,
+      "sha256": "08fbd3820bace55861948c392a130ab934895d2d75a54e7e1666aabdf0ba16e1"
+    }
+  ],
+  "precompiled": [
+    {
+      "path": "npu/qualcomm/gliner25_decide_fp16hw_SM8850.tflite",
+      "soc": "SM8850",
+      "snapdragon": "8 Elite Gen 5",
+      "hexagon": "V81",
+      "signatures": [
+        "s128",
+        "s160",
+        "s256",
+        "s512"
+      ],
+      "bytes": 876858672,
+      "sha256": "84e72594a330efdb86e09e4319e30f02ed75f63917fc55346ed47351ca1b30c6",
+      "compileSeconds": 1065.2,
+      "checkedOn": "Galaxy Z Fold 8, 2026-11-01"
+    },
+    {
+      "path": "npu/qualcomm/gliner25_decide_fp16hw_SM8750.tflite",
+      "soc": "SM8750",
+      "snapdragon": "8 Elite",
+      "hexagon": "V79",
+      "signatures": [
+        "s128",
+        "s160",
+        "s256",
+        "s512"
+      ],
+      "bytes": 874827056,
+      "sha256": "5357988607b7287eedcbd7328f1db3ed91ed34afc4bce3f8042ae47c5a5b32df",
+      "compileSeconds": 788.9,
+      "checkedOn": null
+    },
+    {
+      "path": "npu/qualcomm/gliner25_decide_fp16hw_SM8650.tflite",
+      "soc": "SM8650",
+      "snapdragon": "8 Gen 3",
+      "hexagon": "V75",
+      "signatures": [
+        "s128",
+        "s160",
+        "s256",
+        "s512"
+      ],
+      "bytes": 860486960,
+      "sha256": "48a382ae593afe724eb40b833991b5c8fb8dbb2bb6b14c74ebf9abb862177e02",
+      "compileSeconds": 787.0,
+      "checkedOn": null
+    },
+    {
+      "path": "npu/qualcomm/gliner25_decide_fp16hw_SM8550.tflite",
+      "soc": "SM8550",
+      "snapdragon": "8 Gen 2",
+      "hexagon": "V73",
+      "signatures": [
+        "s128",
+        "s160",
+        "s256",
+        "s512"
+      ],
+      "bytes": 862100784,
+      "sha256": "86bfd5ca3aea9075dcb0482c04572dcfd247f2f6f3bb040ac0d989d8e60ed6bd",
+      "compileSeconds": 951.1,
+      "checkedOn": "Galaxy S23 Ultra, 2026-11-02"
+    },
+    {
+      "path": "npu/qualcomm/gliner25_decide_fp16hw_SM8450.tflite",
+      "soc": "SM8450",
+      "snapdragon": "8 Gen 1",
+      "hexagon": "V69",
+      "signatures": [
+        "s128",
+        "s160",
+        "s256",
+        "s512"
+      ],
+      "bytes": 855567664,
+      "sha256": "b82f3b26b9cd9ce59ea1340486e81bec51a4aae6fcb7b5ff7769b717326dc32a",
+      "compileSeconds": 342.1,
+      "checkedOn": null
+    }
+  ]
+}

npu/qualcomm/gliner25_decide_fp16hw_SM8450.tflite

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

npu/qualcomm/gliner25_decide_fp16hw_SM8550.tflite

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

npu/qualcomm/gliner25_decide_fp16hw_SM8650.tflite

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

npu/qualcomm/gliner25_decide_fp16hw_SM8750.tflite

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

npu/qualcomm/gliner25_decide_fp16hw_SM8850.tflite

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

source/config.json

@@ -0,0 +1,24 @@
+{
+  "_attn_implementation_autoset": true,
+  "_name_or_path": "/home/urchadezaratiana/checkpoints/checkpoint-45500",
+  "architecture": "span",
+  "architecture_version": 1,
+  "architectures": [
+    "SpanExtractor"
+  ],
+  "attn_implementation": "sdpa",
+  "config_version": 3,
+  "counting_layer": "count_lstm",
+  "max_len": null,
+  "max_width": 8,
+  "model_name": "microsoft/deberta-v3-large",
+  "model_type": "extractor",
+  "span_head": {
+    "dropout": 0.1,
+    "max_width": 8,
+    "span_mode": "markerV0"
+  },
+  "token_pooling": "first",
+  "transformers_version": "4.48.1",
+  "use_moe": false
+}

source/encoder_config/config.json

@@ -0,0 +1,34 @@
+{
+  "_attn_implementation_autoset": true,
+  "_name_or_path": "/home/urchadezaratiana/checkpoints/checkpoint-45500/encoder_config/config.json",
+  "attention_probs_dropout_prob": 0.1,
+  "dtype": "float32",
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 1024,
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "layer_norm_eps": 1e-07,
+  "legacy": true,
+  "max_position_embeddings": 512,
+  "max_relative_positions": -1,
+  "model_type": "deberta-v2",
+  "norm_rel_ebd": "layer_norm",
+  "num_attention_heads": 16,
+  "num_hidden_layers": 24,
+  "pad_token_id": 0,
+  "pooler_dropout": 0,
+  "pooler_hidden_act": "gelu",
+  "pooler_hidden_size": 1024,
+  "pos_att_type": [
+    "p2c",
+    "c2p"
+  ],
+  "position_biased_input": false,
+  "position_buckets": 256,
+  "relative_attention": true,
+  "share_att_key": true,
+  "transformers_version": "4.48.1",
+  "type_vocab_size": 0,
+  "vocab_size": 128011
+}

special_tokens_map.json

@@ -0,0 +1,123 @@
+{
+  "additional_special_tokens": [
+    {
+      "content": "[SEP_STRUCT]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "[SEP_TEXT]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "[P]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "[C]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "[E]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "[R]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "[L]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "[EXAMPLE]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "[OUTPUT]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    },
+    {
+      "content": "[DESCRIPTION]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false
+    }
+  ],
+  "bos_token": {
+    "content": "[CLS]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "cls_token": {
+    "content": "[CLS]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "[SEP]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "mask_token": {
+    "content": "[MASK]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": {
+    "content": "[PAD]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "sep_token": {
+    "content": "[SEP]",
+    "lstrip": false,
+    "normalized": false,
+    "rstrip": false,
+    "single_word": false
+  },
+  "unk_token": {
+    "content": "[UNK]",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  }
+}

tokenizer_config.json

@@ -0,0 +1,156 @@
+{
+  "add_prefix_space": true,
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128000": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128001": {
+      "content": "[SEP_STRUCT]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128002": {
+      "content": "[SEP_TEXT]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128003": {
+      "content": "[P]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128004": {
+      "content": "[C]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128005": {
+      "content": "[E]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128006": {
+      "content": "[R]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128007": {
+      "content": "[L]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128008": {
+      "content": "[EXAMPLE]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128009": {
+      "content": "[OUTPUT]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "128010": {
+      "content": "[DESCRIPTION]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "additional_special_tokens": [
+    "[SEP_STRUCT]",
+    "[SEP_TEXT]",
+    "[P]",
+    "[C]",
+    "[E]",
+    "[R]",
+    "[L]",
+    "[EXAMPLE]",
+    "[OUTPUT]",
+    "[DESCRIPTION]"
+  ],
+  "backend": "tokenizers",
+  "bos_token": "[CLS]",
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "[CLS]",
+  "do_lower_case": false,
+  "eos_token": "[SEP]",
+  "extra_special_tokens": {},
+  "is_local": false,
+  "local_files_only": false,
+  "mask_token": "[MASK]",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "sp_model_kwargs": {},
+  "split_by_punct": false,
+  "tokenizer_class": "DebertaV2Tokenizer",
+  "unk_id": 3,
+  "unk_token": "[UNK]",
+  "vocab_type": "spm"
+}

validation.json

@@ -0,0 +1,1527 @@
+{
+ "model": "gliner25-decide-litert",
+ "source": "fastino/GLiNER2.5-Decide@bbe10ff77ebb238777c17d3a8ac9260e30929057",
+ "date": "2026-10-28",
+ "versions": {
+  "litert-torch": "0.9.4",
+  "ai-edge-litert": "2.2.0",
+  "ai-edge-quantizer": "0.9.0",
+  "litert-converter": "0.4.0",
+  "torch": "2.13.0",
+  "transformers": "4.57.6",
+  "gliner2": "2.0.0"
+ },
+ "machine": "arm64 Mac (Apple M5 Max, macOS 27.0.1)",
+ "buckets": [
+  128,
+  160,
+  256,
+  512
+ ],
+ "threads": 4,
+ "corpus": {
+  "calls": 616,
+  "quick": false,
+  "source": "gliner2 2.0.0 library calls recorded on a synthetic English corpus of short conversational statements",
+  "byBucket": {
+   "128": 8,
+   "160": 321,
+   "512": 287
+  }
+ },
+ "gate": {
+  "agreement": 0.95,
+  "drift": 0.05
+ },
+ "variants": {
+  "wfp16": {
+   "about": "FULLY_CONNECTED weights stored float16 behind DEQUANTIZE (ai-edge-quantizer FLOAT_CASTING); FP32 activations, relative-position tables, norms and biases; finite -1e4 mask",
+   "file": "gliner25_decide_wfp16.tflite",
+   "bytes": 1026117712,
+   "buildSeconds": 5.6,
+   "tableSharing": null,
+   "tablesFp16": null,
+   "audit": {
+    "bytes": 1026117712,
+    "signatures": [
+     {
+      "key": "s128",
+      "inputs": [
+       {
+        "name": "attention_mask",
+        "dtype": "float32",
+        "shape": [
+         1,
+         128
+        ]
+       },
+       {
+        "name": "inputs_embeds",
+        "dtype": "float32",
+        "shape": [
+         1,
+         128,
+         1024
+        ]
+       }
+      ],
+      "outputs": [
+       {
+        "name": "logits",
+        "dtype": "float32",
+        "shape": [
+         1,
+         128
+        ]
+       }
+      ]
+     },
+     {
+      "key": "s160",
+      "inputs": [
+       {
+        "name": "attention_mask",
+        "dtype": "float32",
+        "shape": [
+         1,
+         160
+        ]
+       },
+       {
+        "name": "inputs_embeds",
+        "dtype": "float32",
+        "shape": [
+         1,
+         160,
+         1024
+        ]
+       }
+      ],
+      "outputs": [
+       {
+        "name": "logits",
+        "dtype": "float32",
+        "shape": [
+         1,
+         160
+        ]
+       }
+      ]
+     },
+     {
+      "key": "s256",
+      "inputs": [
+       {
+        "name": "attention_mask",
+        "dtype": "float32",
+        "shape": [
+         1,
+         256
+        ]
+       },
+       {
+        "name": "inputs_embeds",
+        "dtype": "float32",
+        "shape": [
+         1,
+         256,
+         1024
+        ]
+       }
+      ],
+      "outputs": [
+       {
+        "name": "logits",
+        "dtype": "float32",
+        "shape": [
+         1,
+         256
+        ]
+       }
+      ]
+     },
+     {
+      "key": "s512",
+      "inputs": [
+       {
+        "name": "attention_mask",
+        "dtype": "float32",
+        "shape": [
+         1,
+         512
+        ]
+       },
+       {
+        "name": "inputs_embeds",
+        "dtype": "float32",
+        "shape": [
+         1,
+         512,
+         1024
+        ]
+       }
+      ],
+      "outputs": [
+       {
+        "name": "logits",
+        "dtype": "float32",
+        "shape": [
+         1,
+         512
+        ]
+       }
+      ]
+     }
+    ],
+    "operators": {
+     "s128": 1749,
+     "s160": 1749,
+     "s256": 1749,
+     "s512": 1749
+    },
+    "opHistogram": {
+     "s128": {
+      "ADD": 266,
+      "BATCH_MATMUL": 96,
+      "DEQUANTIZE": 146,
+      "FULLY_CONNECTED": 146,
+      "GELU": 24,
+      "MEAN": 98,
+      "MUL": 220,
+      "RESHAPE": 341,
+      "RSQRT": 49,
+      "SLICE": 96,
+      "SOFTMAX": 24,
+      "SQUARED_DIFFERENCE": 49,
+      "SUB": 50,
+      "TRANSPOSE": 144
+     },
+     "s160": {
+      "ADD": 266,
+      "BATCH_MATMUL": 96,
+      "DEQUANTIZE": 146,
+      "FULLY_CONNECTED": 146,
+      "GELU": 24,
+      "MEAN": 98,
+      "MUL": 220,
+      "RESHAPE": 341,
+      "RSQRT": 49,
+      "SLICE": 96,
+      "SOFTMAX": 24,
+      "SQUARED_DIFFERENCE": 49,
+      "SUB": 50,
+      "TRANSPOSE": 144
+     },
+     "s256": {
+      "ADD": 266,
+      "BATCH_MATMUL": 96,
+      "DEQUANTIZE": 146,
+      "FULLY_CONNECTED": 146,
+      "GELU": 24,
+      "MEAN": 98,
+      "MUL": 220,
+      "RESHAPE": 341,
+      "RSQRT": 49,
+      "SLICE": 96,
+      "SOFTMAX": 24,
+      "SQUARED_DIFFERENCE": 49,
+      "SUB": 50,
+      "TRANSPOSE": 144
+     },
+     "s512": {
+      "ADD": 266,
+      "BATCH_MATMUL": 96,
+      "DEQUANTIZE": 146,
+      "FULLY_CONNECTED": 146,
+      "GELU": 24,
+      "MEAN": 98,
+      "MUL": 220,
+      "RESHAPE": 341,
+      "RSQRT": 49,
+      "SLICE": 96,
+      "SOFTMAX": 24,
+      "SQUARED_DIFFERENCE": 49,
+      "SUB": 50,
+      "TRANSPOSE": 144
+     }
+    },
+    "tensorDtypes": {
+     "FLOAT32": 8184,
+     "FLOAT16": 584,
+     "INT32": 60
+    },
+    "int64Tensors": 0,
+    "constantBytesBySignatures": {
+     "s128+s160+s256+s512": 609464416,
+     "s512": 201326716,
+     "s256": 100663420,
+     "s160": 62914684,
+     "s128": 50331772
+    },
+    "activationsWithLeadingDimNot1": [
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     }
+    ]
+   },
+   "parity": {
+    "cpu": {
+     "calls": 616,
+     "decisions": 2338,
+     "agree": 2338,
+     "agreement": 1.0,
+     "driftMax": 0.00032,
+     "driftP99": 0.00017,
+     "driftP50": 1.7e-05,
+     "over005": 0,
+     "msByBucket": {
+      "128": {
+       "calls": 8,
+       "p50": 58.3,
+       "p95": 64.8
+      },
+      "160": {
+       "calls": 321,
+       "p50": 68.1,
+       "p95": 70.5
+      },
+      "512": {
+       "calls": 287,
+       "p50": 248.6,
+       "p95": 255.8
+      }
+     },
+     "loadSeconds": 0.53,
+     "fullyAccelerated": true,
+     "gate": "pass"
+    },
+    "gpu_fp32": {
+     "calls": 616,
+     "decisions": 2338,
+     "agree": 2338,
+     "agreement": 1.0,
+     "driftMax": 0.00032,
+     "driftP99": 0.00017,
+     "driftP50": 1.7e-05,
+     "over005": 0,
+     "msByBucket": {
+      "128": {
+       "calls": 8,
+       "p50": 21.0,
+       "p95": 21.9
+      },
+      "160": {
+       "calls": 321,
+       "p50": 23.8,
+       "p95": 25.4
+      },
+      "512": {
+       "calls": 287,
+       "p50": 76.1,
+       "p95": 79.5
+      }
+     },
+     "loadSeconds": 1.8,
+     "fullyAccelerated": true,
+     "gate": "pass"
+    },
+    "gpu_fp16": {
+     "calls": 616,
+     "decisions": 2338,
+     "agree": 2226,
+     "agreement": 0.9521,
+     "driftMax": 0.30555,
+     "driftP99": 0.12811,
+     "driftP50": 0.012985,
+     "over005": 241,
+     "msByBucket": {
+      "128": {
+       "calls": 8,
+       "p50": 16.3,
+       "p95": 16.3
+      },
+      "160": {
+       "calls": 321,
+       "p50": 20.5,
+       "p95": 20.8
+      },
+      "512": {
+       "calls": 287,
+       "p50": 49.6,
+       "p95": 49.8
+      }
+     },
+     "loadSeconds": 1.73,
+     "fullyAccelerated": true,
+     "gate": [
+      "probability drift 0.30555"
+     ]
+    }
+   },
+   "logitDifferenceFromTorch": {
+    "cpu": {
+     "160": 0.000954,
+     "512": 0.0015
+    },
+    "gpu_fp32": {
+     "160": 0.000952,
+     "512": 0.00151
+    },
+    "gpu_fp16": {
+     "160": 1.24,
+     "512": 0.556
+    }
+   },
+   "memory": {
+    "cpuNoCache": {
+     "loadSeconds": 0.62,
+     "baseline": {
+      "rssMb": 194.2,
+      "footprintMb": 149.3
+     },
+     "afterLoad": {
+      "rssMb": 6374.3,
+      "footprintMb": 5348.1
+     },
+     "afterEachSignature": {
+      "s128": {
+       "rssMb": 6385.7,
+       "footprintMb": 5359.0
+      },
+      "s160": {
+       "rssMb": 6403.3,
+       "footprintMb": 5376.6
+      },
+      "s256": {
+       "rssMb": 6441.6,
+       "footprintMb": 5414.9
+      },
+      "s512": {
+       "rssMb": 6583.8,
+       "footprintMb": 5557.2
+      }
+     },
+     "peakRssMb": 6583.8
+    },
+    "cpuCacheFirst": {
+     "loadSeconds": 0.33,
+     "baseline": {
+      "rssMb": 194.2,
+      "footprintMb": 149.3
+     },
+     "afterLoad": {
+      "rssMb": 1708.6,
+      "footprintMb": 679.0
+     },
+     "afterEachSignature": {
+      "s128": {
+       "rssMb": 2871.1,
+       "footprintMb": 680.4
+      },
+      "s160": {
+       "rssMb": 2888.9,
+       "footprintMb": 698.3
+      },
+      "s256": {
+       "rssMb": 2927.2,
+       "footprintMb": 736.6
+      },
+      "s512": {
+       "rssMb": 3069.4,
+       "footprintMb": 878.8
+      }
+     },
+     "peakRssMb": 3069.4
+    },
+    "cpuCacheWarm": {
+     "loadSeconds": 0.22,
+     "baseline": {
+      "rssMb": 194.5,
+      "footprintMb": 149.5
+     },
+     "afterLoad": {
+      "rssMb": 1691.0,
+      "footprintMb": 661.5
+     },
+     "afterEachSignature": {
+      "s128": {
+       "rssMb": 2853.5,
+       "footprintMb": 662.9
+      },
+      "s160": {
+       "rssMb": 2871.3,
+       "footprintMb": 680.7
+      },
+      "s256": {
+       "rssMb": 2909.6,
+       "footprintMb": 719.0
+      },
+      "s512": {
+       "rssMb": 3051.8,
+       "footprintMb": 861.4
+      }
+     },
+     "peakRssMb": 3051.8
+    }
+   }
+  },
+  "fp16hw": {
+   "about": "wfp16's storage (float16 FULLY_CONNECTED weights behind DEQUANTIZE) over the FP16-hardware graph: LayerNorm power-of-two pre-scale (x*2^-k, eps*4^-k, k from the corpus' FP32 ranges), first feed-forward FULLY_CONNECTED split in two halves, finite -1e4 mask",
+   "file": "gliner25_decide_fp16hw.tflite",
+   "bytes": 1026073648,
+   "buildSeconds": 5.7,
+   "tableSharing": null,
+   "tablesFp16": null,
+   "audit": {
+    "bytes": 1026073648,
+    "signatures": [
+     {
+      "key": "s128",
+      "inputs": [
+       {
+        "name": "attention_mask",
+        "dtype": "float32",
+        "shape": [
+         1,
+         128
+        ]
+       },
+       {
+        "name": "inputs_embeds",
+        "dtype": "float32",
+        "shape": [
+         1,
+         128,
+         1024
+        ]
+       }
+      ],
+      "outputs": [
+       {
+        "name": "logits",
+        "dtype": "float32",
+        "shape": [
+         1,
+         128
+        ]
+       }
+      ]
+     },
+     {
+      "key": "s160",
+      "inputs": [
+       {
+        "name": "attention_mask",
+        "dtype": "float32",
+        "shape": [
+         1,
+         160
+        ]
+       },
+       {
+        "name": "inputs_embeds",
+        "dtype": "float32",
+        "shape": [
+         1,
+         160,
+         1024
+        ]
+       }
+      ],
+      "outputs": [
+       {
+        "name": "logits",
+        "dtype": "float32",
+        "shape": [
+         1,
+         160
+        ]
+       }
+      ]
+     },
+     {
+      "key": "s256",
+      "inputs": [
+       {
+        "name": "attention_mask",
+        "dtype": "float32",
+        "shape": [
+         1,
+         256
+        ]
+       },
+       {
+        "name": "inputs_embeds",
+        "dtype": "float32",
+        "shape": [
+         1,
+         256,
+         1024
+        ]
+       }
+      ],
+      "outputs": [
+       {
+        "name": "logits",
+        "dtype": "float32",
+        "shape": [
+         1,
+         256
+        ]
+       }
+      ]
+     },
+     {
+      "key": "s512",
+      "inputs": [
+       {
+        "name": "attention_mask",
+        "dtype": "float32",
+        "shape": [
+         1,
+         512
+        ]
+       },
+       {
+        "name": "inputs_embeds",
+        "dtype": "float32",
+        "shape": [
+         1,
+         512,
+         1024
+        ]
+       }
+      ],
+      "outputs": [
+       {
+        "name": "logits",
+        "dtype": "float32",
+        "shape": [
+         1,
+         512
+        ]
+       }
+      ]
+     }
+    ],
+    "operators": {
+     "s128": 1846,
+     "s160": 1846,
+     "s256": 1846,
+     "s512": 1846
+    },
+    "opHistogram": {
+     "s128": {
+      "ADD": 266,
+      "BATCH_MATMUL": 96,
+      "CONCATENATION": 24,
+      "DEQUANTIZE": 170,
+      "FULLY_CONNECTED": 170,
+      "GELU": 24,
+      "MEAN": 98,
+      "MUL": 245,
+      "RESHAPE": 341,
+      "RSQRT": 49,
+      "SLICE": 96,
+      "SOFTMAX": 24,
+      "SQUARED_DIFFERENCE": 49,
+      "SUB": 50,
+      "TRANSPOSE": 144
+     },
+     "s160": {
+      "ADD": 266,
+      "BATCH_MATMUL": 96,
+      "CONCATENATION": 24,
+      "DEQUANTIZE": 170,
+      "FULLY_CONNECTED": 170,
+      "GELU": 24,
+      "MEAN": 98,
+      "MUL": 245,
+      "RESHAPE": 341,
+      "RSQRT": 49,
+      "SLICE": 96,
+      "SOFTMAX": 24,
+      "SQUARED_DIFFERENCE": 49,
+      "SUB": 50,
+      "TRANSPOSE": 144
+     },
+     "s256": {
+      "ADD": 266,
+      "BATCH_MATMUL": 96,
+      "CONCATENATION": 24,
+      "DEQUANTIZE": 170,
+      "FULLY_CONNECTED": 170,
+      "GELU": 24,
+      "MEAN": 98,
+      "MUL": 245,
+      "RESHAPE": 341,
+      "RSQRT": 49,
+      "SLICE": 96,
+      "SOFTMAX": 24,
+      "SQUARED_DIFFERENCE": 49,
+      "SUB": 50,
+      "TRANSPOSE": 144
+     },
+     "s512": {
+      "ADD": 266,
+      "BATCH_MATMUL": 96,
+      "CONCATENATION": 24,
+      "DEQUANTIZE": 170,
+      "FULLY_CONNECTED": 170,
+      "GELU": 24,
+      "MEAN": 98,
+      "MUL": 245,
+      "RESHAPE": 341,
+      "RSQRT": 49,
+      "SLICE": 96,
+      "SOFTMAX": 24,
+      "SQUARED_DIFFERENCE": 49,
+      "SUB": 50,
+      "TRANSPOSE": 144
+     }
+    },
+    "tensorDtypes": {
+     "FLOAT32": 8716,
+     "FLOAT16": 680,
+     "INT32": 60
+    },
+    "int64Tensors": 0,
+    "constantBytesBySignatures": {
+     "s128+s160+s256+s512": 609464464,
+     "s512": 201326716,
+     "s256": 100663420,
+     "s160": 62914684,
+     "s128": 50331772
+    },
+    "activationsWithLeadingDimNot1": [
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     }
+    ]
+   },
+   "parity": {
+    "cpu": {
+     "calls": 616,
+     "decisions": 2338,
+     "agree": 2338,
+     "agreement": 1.0,
+     "driftMax": 0.00032,
+     "driftP99": 0.00017,
+     "driftP50": 1.7e-05,
+     "over005": 0,
+     "msByBucket": {
+      "128": {
+       "calls": 8,
+       "p50": 60.2,
+       "p95": 61.2
+      },
+      "160": {
+       "calls": 321,
+       "p50": 70.5,
+       "p95": 72.1
+      },
+      "512": {
+       "calls": 287,
+       "p50": 255.1,
+       "p95": 263.6
+      }
+     },
+     "loadSeconds": 0.61,
+     "fullyAccelerated": true,
+     "gate": "pass"
+    },
+    "gpu_fp32": {
+     "calls": 616,
+     "decisions": 2338,
+     "agree": 2338,
+     "agreement": 1.0,
+     "driftMax": 0.00032,
+     "driftP99": 0.00017,
+     "driftP50": 1.7e-05,
+     "over005": 0,
+     "msByBucket": {
+      "128": {
+       "calls": 8,
+       "p50": 22.1,
+       "p95": 22.6
+      },
+      "160": {
+       "calls": 321,
+       "p50": 25.7,
+       "p95": 27.2
+      },
+      "512": {
+       "calls": 287,
+       "p50": 79.8,
+       "p95": 84.1
+      }
+     },
+     "loadSeconds": 1.92,
+     "fullyAccelerated": true,
+     "gate": "pass"
+    },
+    "gpu_fp16": {
+     "calls": 616,
+     "decisions": 2338,
+     "agree": 2332,
+     "agreement": 0.9974,
+     "driftMax": 0.01158,
+     "driftP99": 0.00692,
+     "driftP50": 0.001026,
+     "over005": 0,
+     "msByBucket": {
+      "128": {
+       "calls": 8,
+       "p50": 16.6,
+       "p95": 16.9
+      },
+      "160": {
+       "calls": 321,
+       "p50": 22.1,
+       "p95": 22.6
+      },
+      "512": {
+       "calls": 287,
+       "p50": 50.7,
+       "p95": 54.7
+      }
+     },
+     "loadSeconds": 1.74,
+     "fullyAccelerated": true,
+     "gate": "pass"
+    }
+   },
+   "logitDifferenceFromTorch": {
+    "cpu": {
+     "160": 0.000954,
+     "512": 0.0015
+    },
+    "gpu_fp32": {
+     "160": 0.000952,
+     "512": 0.00151
+    },
+    "gpu_fp16": {
+     "160": 0.0228,
+     "512": 0.0376
+    }
+   },
+   "memory": {
+    "cpuNoCache": {
+     "loadSeconds": 0.7,
+     "baseline": {
+      "rssMb": 194.3,
+      "footprintMb": 149.4
+     },
+     "afterLoad": {
+      "rssMb": 7479.4,
+      "footprintMb": 6453.6
+     },
+     "afterEachSignature": {
+      "s128": {
+       "rssMb": 7490.3,
+       "footprintMb": 6464.0
+      },
+      "s160": {
+       "rssMb": 7507.9,
+       "footprintMb": 6481.6
+      },
+      "s256": {
+       "rssMb": 7543.6,
+       "footprintMb": 6517.3
+      },
+      "s512": {
+       "rssMb": 7685.7,
+       "footprintMb": 6659.5
+      }
+     },
+     "peakRssMb": 7685.7
+    },
+    "cpuCacheFirst": {
+     "loadSeconds": 0.35,
+     "baseline": {
+      "rssMb": 194.5,
+      "footprintMb": 149.6
+     },
+     "afterLoad": {
+      "rssMb": 1805.6,
+      "footprintMb": 776.1
+     },
+     "afterEachSignature": {
+      "s128": {
+       "rssMb": 2968.6,
+       "footprintMb": 778.0
+      },
+      "s160": {
+       "rssMb": 2986.3,
+       "footprintMb": 795.6
+      },
+      "s256": {
+       "rssMb": 3022.0,
+       "footprintMb": 831.4
+      },
+      "s512": {
+       "rssMb": 3164.3,
+       "footprintMb": 973.8
+      }
+     },
+     "peakRssMb": 3164.3
+    },
+    "cpuCacheWarm": {
+     "loadSeconds": 0.23,
+     "baseline": {
+      "rssMb": 194.5,
+      "footprintMb": 149.5
+     },
+     "afterLoad": {
+      "rssMb": 1783.5,
+      "footprintMb": 754.0
+     },
+     "afterEachSignature": {
+      "s128": {
+       "rssMb": 2946.5,
+       "footprintMb": 755.9
+      },
+      "s160": {
+       "rssMb": 2964.1,
+       "footprintMb": 773.5
+      },
+      "s256": {
+       "rssMb": 2999.8,
+       "footprintMb": 809.2
+      },
+      "s512": {
+       "rssMb": 3142.1,
+       "footprintMb": 951.5
+      }
+     },
+     "peakRssMb": 3142.1
+    }
+   }
+  },
+  "int8": {
+   "about": "dynamic-range int8 weights (ai-edge-quantizer dynamic_wi8_afp32: FULLY_CONNECTED and BATCH_MATMUL constants int8 per channel, activations quantized per call); CPU only",
+   "file": "gliner25_decide_int8.tflite",
+   "bytes": 422418624,
+   "buildSeconds": 1.6,
+   "tableSharing": null,
+   "tablesFp16": null,
+   "audit": {
+    "bytes": 422418624,
+    "signatures": [
+     {
+      "key": "s128",
+      "inputs": [
+       {
+        "name": "attention_mask",
+        "dtype": "float32",
+        "shape": [
+         1,
+         128
+        ]
+       },
+       {
+        "name": "inputs_embeds",
+        "dtype": "float32",
+        "shape": [
+         1,
+         128,
+         1024
+        ]
+       }
+      ],
+      "outputs": [
+       {
+        "name": "logits",
+        "dtype": "float32",
+        "shape": [
+         1,
+         128
+        ]
+       }
+      ]
+     },
+     {
+      "key": "s160",
+      "inputs": [
+       {
+        "name": "attention_mask",
+        "dtype": "float32",
+        "shape": [
+         1,
+         160
+        ]
+       },
+       {
+        "name": "inputs_embeds",
+        "dtype": "float32",
+        "shape": [
+         1,
+         160,
+         1024
+        ]
+       }
+      ],
+      "outputs": [
+       {
+        "name": "logits",
+        "dtype": "float32",
+        "shape": [
+         1,
+         160
+        ]
+       }
+      ]
+     },
+     {
+      "key": "s256",
+      "inputs": [
+       {
+        "name": "attention_mask",
+        "dtype": "float32",
+        "shape": [
+         1,
+         256
+        ]
+       },
+       {
+        "name": "inputs_embeds",
+        "dtype": "float32",
+        "shape": [
+         1,
+         256,
+         1024
+        ]
+       }
+      ],
+      "outputs": [
+       {
+        "name": "logits",
+        "dtype": "float32",
+        "shape": [
+         1,
+         256
+        ]
+       }
+      ]
+     },
+     {
+      "key": "s512",
+      "inputs": [
+       {
+        "name": "attention_mask",
+        "dtype": "float32",
+        "shape": [
+         1,
+         512
+        ]
+       },
+       {
+        "name": "inputs_embeds",
+        "dtype": "float32",
+        "shape": [
+         1,
+         512,
+         1024
+        ]
+       }
+      ],
+      "outputs": [
+       {
+        "name": "logits",
+        "dtype": "float32",
+        "shape": [
+         1,
+         512
+        ]
+       }
+      ]
+     }
+    ],
+    "operators": {
+     "s128": 1603,
+     "s160": 1603,
+     "s256": 1603,
+     "s512": 1603
+    },
+    "opHistogram": {
+     "s128": {
+      "ADD": 266,
+      "BATCH_MATMUL": 96,
+      "FULLY_CONNECTED": 146,
+      "GELU": 24,
+      "MEAN": 98,
+      "MUL": 220,
+      "RESHAPE": 341,
+      "RSQRT": 49,
+      "SLICE": 96,
+      "SOFTMAX": 24,
+      "SQUARED_DIFFERENCE": 49,
+      "SUB": 50,
+      "TRANSPOSE": 144
+     },
+     "s160": {
+      "ADD": 266,
+      "BATCH_MATMUL": 96,
+      "FULLY_CONNECTED": 146,
+      "GELU": 24,
+      "MEAN": 98,
+      "MUL": 220,
+      "RESHAPE": 341,
+      "RSQRT": 49,
+      "SLICE": 96,
+      "SOFTMAX": 24,
+      "SQUARED_DIFFERENCE": 49,
+      "SUB": 50,
+      "TRANSPOSE": 144
+     },
+     "s256": {
+      "ADD": 266,
+      "BATCH_MATMUL": 96,
+      "FULLY_CONNECTED": 146,
+      "GELU": 24,
+      "MEAN": 98,
+      "MUL": 220,
+      "RESHAPE": 341,
+      "RSQRT": 49,
+      "SLICE": 96,
+      "SOFTMAX": 24,
+      "SQUARED_DIFFERENCE": 49,
+      "SUB": 50,
+      "TRANSPOSE": 144
+     },
+     "s512": {
+      "ADD": 266,
+      "BATCH_MATMUL": 96,
+      "FULLY_CONNECTED": 146,
+      "GELU": 24,
+      "MEAN": 98,
+      "MUL": 220,
+      "RESHAPE": 341,
+      "RSQRT": 49,
+      "SLICE": 96,
+      "SOFTMAX": 24,
+      "SQUARED_DIFFERENCE": 49,
+      "SUB": 50,
+      "TRANSPOSE": 144
+     }
+    },
+    "tensorDtypes": {
+     "FLOAT32": 7408,
+     "INT8": 776,
+     "INT32": 60
+    },
+    "int64Tensors": 0,
+    "constantBytesBySignatures": {
+     "s128+s160+s256+s512": 305375328,
+     "s512": 50331772,
+     "s256": 25165948,
+     "s160": 15728764,
+     "s128": 12583036
+    },
+    "activationsWithLeadingDimNot1": [
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     },
+     {
+      "signature": "s128",
+      "shape": [
+       128,
+       1024
+      ]
+     }
+    ]
+   },
+   "parity": {
+    "cpu": {
+     "calls": 616,
+     "decisions": 2338,
+     "agree": 2306,
+     "agreement": 0.9863,
+     "driftMax": 0.05977,
+     "driftP99": 0.02366,
+     "driftP50": 0.003493,
+     "over005": 1,
+     "msByBucket": {
+      "128": {
+       "calls": 8,
+       "p50": 46.7,
+       "p95": 47.3
+      },
+      "160": {
+       "calls": 321,
+       "p50": 54.5,
+       "p95": 55.5
+      },
+      "512": {
+       "calls": 287,
+       "p50": 219.5,
+       "p95": 224.1
+      }
+     },
+     "loadSeconds": 0.86,
+     "fullyAccelerated": true,
+     "gate": [
+      "probability drift 0.05977"
+     ]
+    }
+   },
+   "logitDifferenceFromTorch": {
+    "cpu": {
+     "160": 0.083,
+     "512": 0.107
+    }
+   },
+   "memory": {
+    "cpuNoCache": {
+     "loadSeconds": 0.9,
+     "baseline": {
+      "rssMb": 194.3,
+      "footprintMb": 149.4
+     },
+     "afterLoad": {
+      "rssMb": 1942.5,
+      "footprintMb": 1489.0
+     },
+     "afterEachSignature": {
+      "s128": {
+       "rssMb": 1954.3,
+       "footprintMb": 1500.3
+      },
+      "s160": {
+       "rssMb": 1971.6,
+       "footprintMb": 1517.6
+      },
+      "s256": {
+       "rssMb": 2008.6,
+       "footprintMb": 1554.7
+      },
+      "s512": {
+       "rssMb": 2152.8,
+       "footprintMb": 1698.9
+      }
+     },
+     "peakRssMb": 2152.8
+    },
+    "cpuCacheFirst": {
+     "loadSeconds": 0.33,
+     "baseline": {
+      "rssMb": 194.2,
+      "footprintMb": 149.3
+     },
+     "afterLoad": {
+      "rssMb": 768.8,
+      "footprintMb": 314.3
+     },
+     "afterEachSignature": {
+      "s128": {
+       "rssMb": 1073.3,
+       "footprintMb": 325.8
+      },
+      "s160": {
+       "rssMb": 1090.7,
+       "footprintMb": 343.1
+      },
+      "s256": {
+       "rssMb": 1128.3,
+       "footprintMb": 380.8
+      },
+      "s512": {
+       "rssMb": 1272.8,
+       "footprintMb": 525.4
+      }
+     },
+     "peakRssMb": 1272.8
+    },
+    "cpuCacheWarm": {
+     "loadSeconds": 0.13,
+     "baseline": {
+      "rssMb": 194.2,
+      "footprintMb": 149.3
+     },
+     "afterLoad": {
+      "rssMb": 473.7,
+      "footprintMb": 310.0
+     },
+     "afterEachSignature": {
+      "s128": {
+       "rssMb": 778.1,
+       "footprintMb": 321.3
+      },
+      "s160": {
+       "rssMb": 795.6,
+       "footprintMb": 338.8
+      },
+      "s256": {
+       "rssMb": 833.2,
+       "footprintMb": 376.4
+      },
+      "s512": {
+       "rssMb": 977.7,
+       "footprintMb": 521.0
+      }
+     },
+     "peakRssMb": 977.7
+    }
+   }
+  }
+ },
+ "fp16hw": {
+  "rule": "k per LayerNorm, the smallest with max |x - mean| * 2^-k <= 32.0 over the FP32 graph's inputs of all 616 recorded calls at their buckets (padding rows included)",
+  "k": {
+   "L00.ln1": 0,
+   "L00.ln2": 3,
+   "L01.ln1": 0,
+   "L01.ln2": 4,
+   "L02.ln1": 0,
+   "L02.ln2": 4,
+   "L03.ln1": 0,
+   "L03.ln2": 3,
+   "L04.ln1": 0,
+   "L04.ln2": 3,
+   "L05.ln1": 0,
+   "L05.ln2": 5,
+   "L06.ln1": 0,
+   "L06.ln2": 6,
+   "L07.ln1": 0,
+   "L07.ln2": 6,
+   "L08.ln1": 0,
+   "L08.ln2": 6,
+   "L09.ln1": 0,
+   "L09.ln2": 6,
+   "L10.ln1": 0,
+   "L10.ln2": 5,
+   "L11.ln1": 0,
+   "L11.ln2": 4,
+   "L12.ln1": 0,
+   "L12.ln2": 5,
+   "L13.ln1": 0,
+   "L13.ln2": 4,
+   "L14.ln1": 0,
+   "L14.ln2": 4,
+   "L15.ln1": 0,
+   "L15.ln2": 3,
+   "L16.ln1": 0,
+   "L16.ln2": 3,
+   "L17.ln1": 0,
+   "L17.ln2": 3,
+   "L18.ln1": 0,
+   "L18.ln2": 4,
+   "L19.ln1": 0,
+   "L19.ln2": 4,
+   "L20.ln1": 0,
+   "L20.ln2": 2,
+   "L21.ln1": 0,
+   "L21.ln2": 2,
+   "L22.ln1": 0,
+   "L22.ln2": 1,
+   "L23.ln1": 1,
+   "L23.ln2": 1,
+   "emb": 0
+  },
+  "maxAbsDeviation": {
+   "L00.ln1": 13.89,
+   "L00.ln2": 185.54,
+   "L01.ln1": 10.56,
+   "L01.ln2": 305.1,
+   "L02.ln1": 13.09,
+   "L02.ln2": 266.54,
+   "L03.ln1": 10.38,
+   "L03.ln2": 136.36,
+   "L04.ln1": 12.7,
+   "L04.ln2": 147.98,
+   "L05.ln1": 30.32,
+   "L05.ln2": 983.72,
+   "L06.ln1": 24.73,
+   "L06.ln2": 1231.3,
+   "L07.ln1": 21.63,
+   "L07.ln2": 1423.23,
+   "L08.ln1": 25.53,
+   "L08.ln2": 1403.17,
+   "L09.ln1": 23.11,
+   "L09.ln2": 1092.32,
+   "L10.ln1": 20.08,
+   "L10.ln2": 945.09,
+   "L11.ln1": 12.93,
+   "L11.ln2": 408.1,
+   "L12.ln1": 13.14,
+   "L12.ln2": 603.89,
+   "L13.ln1": 16.62,
+   "L13.ln2": 319.06,
+   "L14.ln1": 20.06,
+   "L14.ln2": 333.7,
+   "L15.ln1": 23.33,
+   "L15.ln2": 203.17,
+   "L16.ln1": 24.75,
+   "L16.ln2": 145.38,
+   "L17.ln1": 22.85,
+   "L17.ln2": 230.49,
+   "L18.ln1": 21.41,
+   "L18.ln2": 419.01,
+   "L19.ln1": 23.27,
+   "L19.ln2": 364.46,
+   "L20.ln1": 23.82,
+   "L20.ln2": 118.49,
+   "L21.ln1": 23.09,
+   "L21.ln2": 88.98,
+   "L22.ln1": 21.86,
+   "L22.ln2": 37.04,
+   "L23.ln1": 37.22,
+   "L23.ln2": 36.5,
+   "emb": 1.18
+  },
+  "prescaled": 25,
+  "norms": 49
+ }
+}