Publish rc20: faster contextual decoder, fresh holdout v14, updated benchmarks

.gitattributes

@@ -1,35 +1,5 @@
-*.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

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+*.pyc
+.venv/

LICENSE

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,13 @@
+IrishCore-GlobalPointer-ContextPII-135M-v1-rc19
+
+This release is derived from:
+- OpenMed/OpenMed-PII-mLiteClinical-Base-135M-v1 (Apache-2.0)
+
+Training and evaluation data used for this derivative included:
+- temsa/OpenMed-Irish-CorePII-TrainMix-v1
+- temsa/OpenMed-Irish-PPSN-Eircode-Spec-v1
+- joelniklaus/mapa (CC-BY-4.0)
+- gretelai/synthetic_pii_finance_multilingual (Apache-2.0)
+
+Additional local synthetic hardening, UAT replay, and holdout sets were used during model selection.
+Please review upstream licenses and dataset cards before redistributing derivative datasets.

PORTFOLIO_COMPARISON.md

@@ -0,0 +1,81 @@
+## Portfolio Comparison
+
+Updated: `2026-03-15`.
+
+Use this section for the fastest public comparison across the `temsa` PII masking portfolio.
+
+- The first core table only includes public checkpoints that ship both comparable q8 accuracy and q8 CPU throughput.
+- The first PPSN table only includes public artifacts that ship comparable PPSN accuracy and CPU throughput.
+- Missing cells in the archive tables mean the older release did not ship that metric in its public bundle.
+- DiffMask rows use the reconciled `clean_single_pass` harness that matches the deployed runtime.
+- GlobalPointer rows use the public raw-only span-matrix release bundle and its packaged q8 ONNX artifact.
+- The same content is shipped as `PORTFOLIO_COMPARISON.md` inside each public model repo.
+
+### Irish Core PII: Comparable Public Checkpoints
+
+| Repo | Stack | Full Core F1 | Q8 Core F1 | Q8 Multilingual PPSN F1 | Q8 Core ex/s |
+|---|---|---:|---:|---:|---:|
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc19`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc19) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 73.1 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc18`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc18) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 126.2 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc17`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc17) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 125.5 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc16`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc16) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 125.5 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc15`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc15) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 125.5 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc14`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc14) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 119.2 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc13`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc13) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 126.1 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc12`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc12) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 73.6 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc11`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc11) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 94.1 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc10`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc10) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 125.8 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc9`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc9) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 119.8 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc8`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc8) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 128.9 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc7`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc7) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 89.0 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc6`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc6) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 89.0 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc5`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc5) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 84.5 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc4`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc4) | GlobalPointer raw-only + context labels | 0.9935 | 0.9935 | 0.9333 | 61.5 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc3`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc3) | GlobalPointer raw-only + context labels | 0.9935 | 0.9935 | 0.9333 | 61.5 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc2`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc2) | GlobalPointer raw-only + context labels | 0.9935 | 0.9935 | 0.9222 | 61.5 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc1`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc1) | GlobalPointer raw-only + context labels | 0.9935 | 0.9935 | 0.9222 | 61.5 |
+| [`temsa/IrishCore-GlobalPointer-135M-v1-rc4`](https://huggingface.co/temsa/IrishCore-GlobalPointer-135M-v1-rc4) | GlobalPointer raw-only span-matrix | 1.0000 | 1.0000 | 0.9333 | 221.6 |
+| [`temsa/IrishCore-GlobalPointer-135M-v1-rc3`](https://huggingface.co/temsa/IrishCore-GlobalPointer-135M-v1-rc3) | GlobalPointer raw-only span-matrix | 1.0000 | 1.0000 | 0.9213 | 204.9 |
+| [`temsa/IrishCore-GlobalPointer-135M-v1-rc2`](https://huggingface.co/temsa/IrishCore-GlobalPointer-135M-v1-rc2) | GlobalPointer raw-only span-matrix | 0.9934 | 0.9934 | 0.9326 | 231.2 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc8`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc8) | Raw-only token-span | 0.9737 | 0.9737 | 0.9176 | 46.1 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc7`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc7) | Hybrid classifier + generated scanner spec | 1.0000 | 0.9934 | 1.0000 | 30.0 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc6`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc6) | Hybrid classifier + repair decoders | 1.0000 | 0.9934 | 1.0000 | 29.5 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc5`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc5) | Hybrid classifier + repair decoders | 0.9737 | 0.9669 | 0.9333 | 34.4 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc4`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc4) | Hybrid classifier + repair decoders | 0.9870 | 0.9740 | 0.9600 | 114.2 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc3`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc3) | Hybrid classifier + repair decoders | 0.9806 | 0.9677 | 0.9333 | 44.9 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc2`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc2) | Hybrid classifier + repair decoders | 0.9554 | 0.9615 | 0.7887 | 119.1 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v1`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v1) | Hybrid classifier baseline | 0.9530 | 0.9333 | 0.9882 | 103.3 |
+| [`temsa/IrishCore-DiffMask-135M-v1-rc6`](https://huggingface.co/temsa/IrishCore-DiffMask-135M-v1-rc6) | DiffMask token-span, scanner-free | 0.9801 | 0.9733 | 0.9274 | 130.3 |
+| [`temsa/IrishCore-DiffMask-135M-v1-rc5`](https://huggingface.co/temsa/IrishCore-DiffMask-135M-v1-rc5) | DiffMask token-span, scanner-free | 0.9733 | 0.9733 | 0.9379 | 249.2 |
+| [`temsa/IrishCore-DiffMask-135M-v1-rc4`](https://huggingface.co/temsa/IrishCore-DiffMask-135M-v1-rc4) | DiffMask token-span, scanner-free | 0.9733 | 0.9733 | 0.9371 | 29.5 |
+| [`temsa/IrishCore-DiffMask-135M-v1-rc3`](https://huggingface.co/temsa/IrishCore-DiffMask-135M-v1-rc3) | DiffMask token-span, scanner-free | 0.9664 | 0.9664 | 0.9591 | 30.0 |
+| [`temsa/IrishCore-DiffMask-135M-v1-rc2`](https://huggingface.co/temsa/IrishCore-DiffMask-135M-v1-rc2) | DiffMask token-span, scanner-free | 0.9664 | 0.9664 | 0.9212 | 247.1 |
+| [`temsa/IrishCore-DiffMask-135M-v1-rc1`](https://huggingface.co/temsa/IrishCore-DiffMask-135M-v1-rc1) | DiffMask token-span, scanner-free | 0.9801 | 0.9934 | 0.9412 | 251.2 |
+
+### Irish Core PII: Other Public Checkpoints
+
+| Repo | Stack | Full Core F1 | Q8 Core F1 | Q8 Multilingual PPSN F1 | Notes |
+|---|---|---:|---:|---:|---|
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc1`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc1) | Hybrid classifier prototype | 0.9487 | — | — | Predates the public q8 artifact. |
+
+Finance-boundary q8 F1 is `1.0000` for `OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc6`, `OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc7`, `OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc8`, and all public `IrishCore-DiffMask` releases from `rc1` to `rc6`. `OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc5` ships `0.8750` on that public q8 suite.
+
+### PPSN-Only: Comparable Public Artifacts
+
+| Repo | Artifact | Irish Large F1 | Multilingual PPSN F1 | User Raw F1 | QA v8 F1 | CPU ex/s |
+|---|---|---:|---:|---:|---:|---:|
+| [`temsa/OpenMed-mLiteClinical-IrishPPSN-135M-v1`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishPPSN-135M-v1) | fp32 canonical checkpoint | 0.8979 | 0.9704 | 0.8000 | 0.7385 | 57.4 |
+| [`temsa/OpenMed-mLiteClinical-IrishPPSN-135M-v1-fp16`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishPPSN-135M-v1-fp16) | fp16 CPU/GPU artifact | — | 0.9704 | 0.8000 | 0.7385 | 45.8 |
+| [`temsa/OpenMed-mLiteClinical-IrishPPSN-135M-v1-q8`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishPPSN-135M-v1-q8) | dynamic int8 CPU artifact | — | 0.9040 | — | — | 132.1 |
+
+### PPSN-Only: Historical Public Checkpoints
+
+| Repo | Main Published Metrics | Notes |
+|---|---|---|
+| [`temsa/OpenMed-PPSN-mLiteClinical-v1`](https://huggingface.co/temsa/OpenMed-PPSN-mLiteClinical-v1) | same as canonical fp32 repo: multilingual 0.9704, user raw 0.8000 | Legacy alias; prefer `temsa/OpenMed-mLiteClinical-IrishPPSN-135M-v1`. |
+| [`temsa/OpenMed-PPSN-v6-raw-rc2`](https://huggingface.co/temsa/OpenMed-PPSN-v6-raw-rc2) | irish_reg_v5 0.8750; user_raw 0.8000; qa_v8 0.7385 | Raw PPSN-only research checkpoint; no packaged multilingual CPU benchmark row. |
+| [`temsa/OpenMed-PPSN-v5_1`](https://huggingface.co/temsa/OpenMed-PPSN-v5_1) | irish_large_v2 raw 0.9285; qa_v6 hybrid strict 1.0000 | Hybrid PPSN-only checkpoint; predates the canonical multilingual suite packaging. |
+| [`temsa/OpenMed-PPSN-v5`](https://huggingface.co/temsa/OpenMed-PPSN-v5) | irish_reg_v5 raw 0.8235; irish_reg_v5 hybrid strict 1.0000 | Hybrid PPSN-only checkpoint; predates the canonical multilingual suite packaging. |
+| [`temsa/OpenMed-PPSN-v4`](https://huggingface.co/temsa/OpenMed-PPSN-v4) | synthetic non-PPSN drift check only | Predates the current PPSN eval suite; no packaged apples-to-apples multilingual CPU row. |
+
+If you need the strongest current raw-only Irish core model, start with `IrishCore-GlobalPointer-135M-v1-rc4`. If you need the fastest CPU-first raw-only line, compare it against `IrishCore-DiffMask-135M-v1-rc6`. If you need a PPSN-only artifact, compare the canonical `fp32`, `fp16`, and `q8` variants of `OpenMed-mLiteClinical-IrishPPSN-135M-v1` directly in the table above.

README.md

@@ -0,0 +1,193 @@
+---
+language:
+- en
+- ga
+license: apache-2.0
+pipeline_tag: token-classification
+tags:
+- pii-masking
+- token-classification
+- globalpointer
+- onnx
+- dynamic-quantization
+- ireland
+- irish
+- gaelic
+---
+# IrishCore-GlobalPointer-ContextPII-135M-v1-rc20
+
+`IrishCore-GlobalPointer-ContextPII-135M-v1-rc20` is the current expanded-label raw-only PII masking release for Irish public-sector, HSE, and citizen-support flows.
+
+It keeps the same DistilBERT-size GlobalPointer span extractor family and the same weights as `temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc19`, but ships a stronger bundled decoder and a faster deployment path for contextual Irish/English address, location, name, date-of-birth, and age recovery.
+
+Context labels served by this line:
+
+- `STREET_ADDRESS`
+- `CITY`
+- `COUNTY`
+- `DATE_OF_BIRTH`
+- `AGE`
+
+Core labels retained:
+
+- `PPSN`
+- `POSTCODE`
+- `PHONE_NUMBER`
+- `EMAIL`
+- `PASSPORT_NUMBER`
+- `ACCOUNT_NUMBER`
+- `BANK_ROUTING_NUMBER`
+- `SWIFT_BIC`
+- `CREDIT_DEBIT_CARD`
+- `FIRST_NAME`
+- `LAST_NAME`
+
+## Positioning
+
+`rc20` is a decoder/runtime hardening release over `rc19`.
+
+- weights unchanged
+- ONNX graph unchanged
+- no external scanner or validator added
+- deployment path still single-pass span extraction plus deterministic `[PII:LABEL]` replacement
+
+What changed in `rc20`:
+
+- Gaelic surname-particle last names such as `Ní Bhroin` and `Nic ...` are recovered cleanly instead of being split into stray `FIRST_NAME` fragments
+- self-cued surnames such as `My name is Maeve O'Sullivan ...` are recovered even when the model only emitted the first token initially
+- cue words such as `Eirchód` are no longer allowed to survive as false `FIRST_NAME` spans
+- q8 CPU throughput improves materially on the aligned suites because span decoding now iterates only over above-threshold candidates and skips expensive repair passes unless the text hints they are needed
+- fresh unseen contextual holdouts `v12`, `v13`, and `v14` all score `1.0000` exact F1 on the q8 deployment path
+
+If you only need the narrower Irish-core structured label set and want maximum CPU throughput, `temsa/IrishCore-GlobalPointer-135M-v1-rc4` remains the faster option.
+
+## Benchmarks
+
+### ONNX q8
+
+| Suite | F1 | Examples/s |
+| --- | ---: | ---: |
+| Irish core | 1.0000 | 181.8821 |
+| Irish extended | 1.0000 | 78.7748 |
+| Gov contact policy v1 | 1.0000 | 150.6650 |
+| Gov chatbot red-team v2 | 0.9861 | 117.0016 |
+| Gov chatbot gap holdout v2 | 1.0000 | 118.2173 |
+| Context red-team v11 exact | 1.0000 | 211.5424 |
+| Context holdout v12 exact | 1.0000 | 77.6876 |
+| Context holdout v13 exact | 1.0000 | 116.3190 |
+| Context holdout v14 exact | 1.0000 | 126.5529 |
+| Multilingual PPSN overall | 0.9333 | 155.2108 |
+| Multilingual PPSN label-only | 1.0000 | — |
+
+### Comparison
+
+| Model | Irish core q8 F1 | Gov chatbot gap holdout v2 q8 F1 | Context holdout v14 exact q8 F1 | Q8 core examples/s |
+| --- | ---: | ---: | ---: | ---: |
+| ContextPII rc20 q8 | 1.0000 | 1.0000 | 1.0000 | 181.8821 |
+| ContextPII rc19 q8 | 1.0000 | 1.0000 | — | 73.0554 |
+| ContextPII rc18 q8 | 1.0000 | 1.0000 | — | 111.3135 |
+| GlobalPointer core rc4 q8 | 1.0000 | 1.0000 | — | 221.5743 |
+
+## Evaluation Notes
+
+Additional q8 release checks shipped in this repo:
+
+- `eval/q8_globalpointer_context_redteam_v11_exact.json`: legacy exact-boundary contextual regression suite, now `1.0000`
+- `eval/q8_globalpointer_context_holdout_v12_exact.json`: fresh unseen holdout for prefixed Irish/English address recovery, now `1.0000`
+- `eval/q8_globalpointer_context_holdout_v13_exact.json`: fresh unseen holdout for house-name and city/county field recovery, now `1.0000`
+- `eval/q8_globalpointer_context_holdout_v14_exact.json`: fresh unseen holdout for Gaelic surname-particle names, apostrophe surnames after self-cues, and mixed structured/contextual packets, now `1.0000`
+- `eval/q8_irish_gov_chatbot_gap_holdout_v2.json`: legacy chatbot gap suite, now `1.0000`
+
+Known tradeoff:
+
+- `eval/q8_irish_gov_chatbot_redteam_v2.json` remains `0.9861` because this broader contextual release masks public-office street/city details in assistant text, while that older suite only labels postcode and phone there.
+
+## Usage
+
+```bash
+python3 inference_mask_onnx.py --model temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc20 --text "My name is Maeve O'Sullivan, my PPSN is 1234567T, and my address is Árasán 4, Cedar Court, mBaile Átha Cliath, D08 XY12."
+```
+
+<!-- portfolio-comparison:start -->
+## Portfolio Comparison
+
+Updated: `2026-03-15`.
+
+Use this section for the fastest public comparison across the `temsa` PII masking portfolio.
+
+- The first core table only includes public checkpoints that ship both comparable q8 accuracy and q8 CPU throughput.
+- The first PPSN table only includes public artifacts that ship comparable PPSN accuracy and CPU throughput.
+- Missing cells in the archive tables mean the older release did not ship that metric in its public bundle.
+- DiffMask rows use the reconciled `clean_single_pass` harness that matches the deployed runtime.
+- GlobalPointer rows use the public raw-only span-matrix release bundle and its packaged q8 ONNX artifact.
+- The same content is shipped as `PORTFOLIO_COMPARISON.md` inside each public model repo.
+
+### Irish Core PII: Comparable Public Checkpoints
+
+| Repo | Stack | Full Core F1 | Q8 Core F1 | Q8 Multilingual PPSN F1 | Q8 Core ex/s |
+|---|---|---:|---:|---:|---:|
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc19`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc19) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 73.1 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc18`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc18) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 126.2 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc17`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc17) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 125.5 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc16`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc16) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 125.5 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc15`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc15) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 125.5 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc14`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc14) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 119.2 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc13`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc13) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 126.1 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc12`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc12) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 73.6 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc11`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc11) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 94.1 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc10`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc10) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 125.8 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc9`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc9) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 119.8 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc8`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc8) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 128.9 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc7`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc7) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 89.0 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc6`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc6) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 89.0 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc5`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc5) | GlobalPointer raw-only + context labels | 1.0000 | 1.0000 | 0.9333 | 84.5 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc4`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc4) | GlobalPointer raw-only + context labels | 0.9935 | 0.9935 | 0.9333 | 61.5 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc3`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc3) | GlobalPointer raw-only + context labels | 0.9935 | 0.9935 | 0.9333 | 61.5 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc2`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc2) | GlobalPointer raw-only + context labels | 0.9935 | 0.9935 | 0.9222 | 61.5 |
+| [`temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc1`](https://huggingface.co/temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc1) | GlobalPointer raw-only + context labels | 0.9935 | 0.9935 | 0.9222 | 61.5 |
+| [`temsa/IrishCore-GlobalPointer-135M-v1-rc4`](https://huggingface.co/temsa/IrishCore-GlobalPointer-135M-v1-rc4) | GlobalPointer raw-only span-matrix | 1.0000 | 1.0000 | 0.9333 | 221.6 |
+| [`temsa/IrishCore-GlobalPointer-135M-v1-rc3`](https://huggingface.co/temsa/IrishCore-GlobalPointer-135M-v1-rc3) | GlobalPointer raw-only span-matrix | 1.0000 | 1.0000 | 0.9213 | 204.9 |
+| [`temsa/IrishCore-GlobalPointer-135M-v1-rc2`](https://huggingface.co/temsa/IrishCore-GlobalPointer-135M-v1-rc2) | GlobalPointer raw-only span-matrix | 0.9934 | 0.9934 | 0.9326 | 231.2 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc8`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc8) | Raw-only token-span | 0.9737 | 0.9737 | 0.9176 | 46.1 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc7`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc7) | Hybrid classifier + generated scanner spec | 1.0000 | 0.9934 | 1.0000 | 30.0 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc6`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc6) | Hybrid classifier + repair decoders | 1.0000 | 0.9934 | 1.0000 | 29.5 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc5`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc5) | Hybrid classifier + repair decoders | 0.9737 | 0.9669 | 0.9333 | 34.4 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc4`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc4) | Hybrid classifier + repair decoders | 0.9870 | 0.9740 | 0.9600 | 114.2 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc3`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc3) | Hybrid classifier + repair decoders | 0.9806 | 0.9677 | 0.9333 | 44.9 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc2`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc2) | Hybrid classifier + repair decoders | 0.9554 | 0.9615 | 0.7887 | 119.1 |
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v1`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v1) | Hybrid classifier baseline | 0.9530 | 0.9333 | 0.9882 | 103.3 |
+| [`temsa/IrishCore-DiffMask-135M-v1-rc6`](https://huggingface.co/temsa/IrishCore-DiffMask-135M-v1-rc6) | DiffMask token-span, scanner-free | 0.9801 | 0.9733 | 0.9274 | 130.3 |
+| [`temsa/IrishCore-DiffMask-135M-v1-rc5`](https://huggingface.co/temsa/IrishCore-DiffMask-135M-v1-rc5) | DiffMask token-span, scanner-free | 0.9733 | 0.9733 | 0.9379 | 249.2 |
+| [`temsa/IrishCore-DiffMask-135M-v1-rc4`](https://huggingface.co/temsa/IrishCore-DiffMask-135M-v1-rc4) | DiffMask token-span, scanner-free | 0.9733 | 0.9733 | 0.9371 | 29.5 |
+| [`temsa/IrishCore-DiffMask-135M-v1-rc3`](https://huggingface.co/temsa/IrishCore-DiffMask-135M-v1-rc3) | DiffMask token-span, scanner-free | 0.9664 | 0.9664 | 0.9591 | 30.0 |
+| [`temsa/IrishCore-DiffMask-135M-v1-rc2`](https://huggingface.co/temsa/IrishCore-DiffMask-135M-v1-rc2) | DiffMask token-span, scanner-free | 0.9664 | 0.9664 | 0.9212 | 247.1 |
+| [`temsa/IrishCore-DiffMask-135M-v1-rc1`](https://huggingface.co/temsa/IrishCore-DiffMask-135M-v1-rc1) | DiffMask token-span, scanner-free | 0.9801 | 0.9934 | 0.9412 | 251.2 |
+
+### Irish Core PII: Other Public Checkpoints
+
+| Repo | Stack | Full Core F1 | Q8 Core F1 | Q8 Multilingual PPSN F1 | Notes |
+|---|---|---:|---:|---:|---|
+| [`temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc1`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc1) | Hybrid classifier prototype | 0.9487 | — | — | Predates the public q8 artifact. |
+
+Finance-boundary q8 F1 is `1.0000` for `OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc6`, `OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc7`, `OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc8`, and all public `IrishCore-DiffMask` releases from `rc1` to `rc6`. `OpenMed-mLiteClinical-IrishCorePII-135M-v2-rc5` ships `0.8750` on that public q8 suite.
+
+### PPSN-Only: Comparable Public Artifacts
+
+| Repo | Artifact | Irish Large F1 | Multilingual PPSN F1 | User Raw F1 | QA v8 F1 | CPU ex/s |
+|---|---|---:|---:|---:|---:|---:|
+| [`temsa/OpenMed-mLiteClinical-IrishPPSN-135M-v1`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishPPSN-135M-v1) | fp32 canonical checkpoint | 0.8979 | 0.9704 | 0.8000 | 0.7385 | 57.4 |
+| [`temsa/OpenMed-mLiteClinical-IrishPPSN-135M-v1-fp16`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishPPSN-135M-v1-fp16) | fp16 CPU/GPU artifact | — | 0.9704 | 0.8000 | 0.7385 | 45.8 |
+| [`temsa/OpenMed-mLiteClinical-IrishPPSN-135M-v1-q8`](https://huggingface.co/temsa/OpenMed-mLiteClinical-IrishPPSN-135M-v1-q8) | dynamic int8 CPU artifact | — | 0.9040 | — | — | 132.1 |
+
+### PPSN-Only: Historical Public Checkpoints
+
+| Repo | Main Published Metrics | Notes |
+|---|---|---|
+| [`temsa/OpenMed-PPSN-mLiteClinical-v1`](https://huggingface.co/temsa/OpenMed-PPSN-mLiteClinical-v1) | same as canonical fp32 repo: multilingual 0.9704, user raw 0.8000 | Legacy alias; prefer `temsa/OpenMed-mLiteClinical-IrishPPSN-135M-v1`. |
+| [`temsa/OpenMed-PPSN-v6-raw-rc2`](https://huggingface.co/temsa/OpenMed-PPSN-v6-raw-rc2) | irish_reg_v5 0.8750; user_raw 0.8000; qa_v8 0.7385 | Raw PPSN-only research checkpoint; no packaged multilingual CPU benchmark row. |
+| [`temsa/OpenMed-PPSN-v5_1`](https://huggingface.co/temsa/OpenMed-PPSN-v5_1) | irish_large_v2 raw 0.9285; qa_v6 hybrid strict 1.0000 | Hybrid PPSN-only checkpoint; predates the canonical multilingual suite packaging. |
+| [`temsa/OpenMed-PPSN-v5`](https://huggingface.co/temsa/OpenMed-PPSN-v5) | irish_reg_v5 raw 0.8235; irish_reg_v5 hybrid strict 1.0000 | Hybrid PPSN-only checkpoint; predates the canonical multilingual suite packaging. |
+| [`temsa/OpenMed-PPSN-v4`](https://huggingface.co/temsa/OpenMed-PPSN-v4) | synthetic non-PPSN drift check only | Predates the current PPSN eval suite; no packaged apples-to-apples multilingual CPU row. |
+
+If you need the strongest current raw-only Irish core model, start with `IrishCore-GlobalPointer-135M-v1-rc4`. If you need the fastest CPU-first raw-only line, compare it against `IrishCore-DiffMask-135M-v1-rc6`. If you need a PPSN-only artifact, compare the canonical `fp32`, `fp16`, and `q8` variants of `OpenMed-mLiteClinical-IrishPPSN-135M-v1` directly in the table above.
+<!-- portfolio-comparison:end -->

common.py

@@ -0,0 +1,2368 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import math
+import re
+from pathlib import Path
+import sys
+from typing import Any
+import unicodedata
+
+import numpy as np
+
+ROOT_DIR = Path(__file__).resolve().parents[2]
+if str(ROOT_DIR) not in sys.path:
+    sys.path.insert(0, str(ROOT_DIR))
+
+try:
+    from ..irish_core_span_raw_only.common import (
+        dedupe_spans,
+        label_max_span_tokens_from_config,
+        label_min_nonspace_chars_from_config,
+        label_names_from_config,
+        load_onnx_session,
+        normalize_entity_name,
+        safe_auto_tokenizer,
+    )
+except ImportError:
+    from experiments.irish_core_span_raw_only.common import (
+        dedupe_spans,
+        label_max_span_tokens_from_config,
+        label_min_nonspace_chars_from_config,
+        label_names_from_config,
+        load_onnx_session,
+        normalize_entity_name,
+        safe_auto_tokenizer,
+    )
+
+
+def label_thresholds_from_config(config, default_threshold: float) -> dict[str, float]:
+    raw = getattr(config, "span_label_thresholds", None) or {}
+    out = {normalize_entity_name(key): float(value) for key, value in raw.items()}
+    for label in label_names_from_config(config):
+        out.setdefault(label, float(default_threshold))
+    return out
+
+
+def valid_offset(offset: tuple[int, int]) -> bool:
+    return bool(offset) and int(offset[1]) > int(offset[0])
+
+
+def nonspace_length(text: str, start: int, end: int) -> int:
+    return sum(0 if ch.isspace() else 1 for ch in text[int(start) : int(end)])
+
+
+def alnum_upper(text: str) -> str:
+    return "".join(ch for ch in text.upper() if ch.isalnum())
+
+
+def normalize_surface(text: str) -> str:
+    value = unicodedata.normalize("NFKD", text)
+    value = "".join(ch for ch in value if not unicodedata.combining(ch))
+    value = value.replace("\u00A0", " ").replace("\u202F", " ")
+    value = re.sub(r"\s+", " ", value.strip().lower())
+    return value
+
+
+IRISH_CITY_FORMS = (
+    "Dublin",
+    "Baile Átha Cliath",
+    "mBaile Átha Cliath",
+    "mBaile Atha Cliath",
+    "Galway",
+    "Gaillimh",
+    "Cork",
+    "Cork City",
+    "Corcaigh",
+    "Limerick",
+    "Luimneach",
+    "Waterford",
+    "Port Láirge",
+    "Kilkenny",
+    "Cill Chainnigh",
+    "Carlow",
+    "Ceatharlach",
+    "Sligo",
+    "Sligeach",
+    "Tralee",
+    "Trá Lí",
+    "Ennis",
+    "Inis",
+    "Letterkenny",
+    "Leitir Ceanainn",
+    "Castlebar",
+    "Caisleán an Bharraigh",
+    "Caislean an Bharraigh",
+    "gCaisleán an Bharraigh",
+    "gCaislean an Bharraigh",
+    "Wexford",
+    "Loch Garman",
+    "Navan",
+    "Uaimh",
+    "An Uaimh",
+    "hUaimh",
+    "nUaimh",
+    "Dundalk",
+    "Dún Dealgan",
+    "Dun Dealgan",
+    "Mullingar",
+    "Muileann gCearr",
+    "An Muileann gCearr",
+    "Tullamore",
+    "Tulach Mhór",
+    "Tulach Mhor",
+    "dTulach Mhór",
+    "dTulach Mhor",
+    "Portlaoise",
+    "Port Laoise",
+    "bPort Laoise",
+    "Bray",
+    "Bré",
+    "Bre",
+    "mBré",
+    "mBre",
+    "Athlone",
+    "Baile Átha Luain",
+    "Baile Atha Luain",
+    "mBaile Átha Luain",
+    "mBaile Atha Luain",
+)
+IRISH_CITY_SURFACES = {normalize_surface(value) for value in IRISH_CITY_FORMS}
+
+IRISH_COUNTY_FORMS = (
+    "Co. Dublin",
+    "County Dublin",
+    "Co. Bhaile Átha Cliath",
+    "Contae Bhaile Átha Cliath",
+    "gContae Bhaile Átha Cliath",
+    "Co. Galway",
+    "County Galway",
+    "Co. na Gaillimhe",
+    "Contae na Gaillimhe",
+    "gContae na Gaillimhe",
+    "Co. Cork",
+    "County Cork",
+    "Co. Chorcaí",
+    "Contae Chorcaí",
+    "gContae Chorcaí",
+    "Co. Limerick",
+    "County Limerick",
+    "Co. Luimnigh",
+    "Contae Luimnigh",
+    "gContae Luimnigh",
+    "Co. Waterford",
+    "County Waterford",
+    "Co. Phort Láirge",
+    "Contae Phort Láirge",
+    "gContae Phort Láirge",
+    "Co. Kilkenny",
+    "County Kilkenny",
+    "Co. Chill Chainnigh",
+    "Contae Chill Chainnigh",
+    "gContae Chill Chainnigh",
+    "Co. Carlow",
+    "County Carlow",
+    "Co. Cheatharlach",
+    "Contae Cheatharlach",
+    "gContae Cheatharlach",
+    "Co. Sligo",
+    "County Sligo",
+    "Co. Shligigh",
+    "Contae Shligigh",
+    "gContae Shligigh",
+    "Co. Kerry",
+    "County Kerry",
+    "Co. Chiarraí",
+    "Contae Chiarraí",
+    "gContae Chiarraí",
+    "Co. Clare",
+    "County Clare",
+    "Co. an Chláir",
+    "Contae an Chláir",
+    "gContae an Chláir",
+    "Co. Donegal",
+    "County Donegal",
+    "Co. Dhún na nGall",
+    "Co. Dhun na nGall",
+    "Contae Dhún na nGall",
+    "Contae Dhun na nGall",
+    "gContae Dhún na nGall",
+    "gContae Dhun na nGall",
+    "Co. Mayo",
+    "County Mayo",
+    "Co. Mhaigh Eo",
+    "Contae Mhaigh Eo",
+    "gContae Mhaigh Eo",
+    "Co. Wexford",
+    "County Wexford",
+    "Co. Loch Garman",
+    "Contae Loch Garman",
+    "gContae Loch Garman",
+    "Co. Meath",
+    "County Meath",
+    "Co. na Mí",
+    "Co. na Mi",
+    "Contae na Mí",
+    "Contae na Mi",
+    "gContae na Mí",
+    "gContae na Mi",
+    "Co. Louth",
+    "County Louth",
+    "Co. Lú",
+    "Co. Lu",
+    "Contae Lú",
+    "Contae Lu",
+    "gContae Lú",
+    "gContae Lu",
+    "Co. Westmeath",
+    "County Westmeath",
+    "Co. na hIarmhí",
+    "Co. na hIarmhi",
+    "Contae na hIarmhí",
+    "Contae na hIarmhi",
+    "gContae na hIarmhí",
+    "gContae na hIarmhi",
+    "Co. Offaly",
+    "County Offaly",
+    "Co. Uíbh Fhailí",
+    "Co. Uibh Fhaili",
+    "Contae Uíbh Fhailí",
+    "Contae Uibh Fhaili",
+    "gContae Uíbh Fhailí",
+    "gContae Uibh Fhaili",
+    "Co. Laois",
+    "County Laois",
+    "Contae Laoise",
+    "gContae Laoise",
+    "Co. Wicklow",
+    "County Wicklow",
+    "Co. Chill Mhantáin",
+    "Co. Chill Mhantain",
+    "Contae Chill Mhantáin",
+    "Contae Chill Mhantain",
+    "gContae Chill Mhantáin",
+    "gContae Chill Mhantain",
+)
+IRISH_COUNTY_SURFACES = {normalize_surface(value) for value in IRISH_COUNTY_FORMS}
+IRISH_CITY_PREFIX_CHARS = {"n", "g", "m", "b", "d", "h"}
+
+STREET_SUFFIX_RE = re.compile(
+    r"(?i)\b(street|road|avenue|lane|park|view|square|terrace|drive|close|way|place|crescent|grove|green|court|manor|mews|gardens?|heights|quay|bóthar|bothar|sráid|sraid|lána|lana)\b"
+)
+BUILDING_SUFFIX_RE = re.compile(
+    r"(?i)\b(house|cottage|lodge|villa|apartments?|building|business\s+centre|community\s+centre|shopping\s+centre|retail\s+park|Teach(?:ín|in)?)\b"
+)
+PHONE_SURFACE_RE = re.compile(r"^[+().\d][+().\d \-/\u00A0\u202F]*\d$")
+ACCOUNT_DIGIT_SURFACE_RE = re.compile(r"^[\d \-\u00A0\u202F]+$")
+MONTH_NAME_RE = (
+    r"(?:January|February|March|April|May|June|July|August|September|October|November|December|"
+    r"Eanáir|Eanair|Feabhra|Márta|Marta|Aibreán|Aibrean|Bealtaine|Meitheamh|Iúil|Iuil|Lúnasa|Lunasa|"
+    r"Meán\s+Fómhair|Mean\s+Fomhair|Deireadh\s+Fómhair|Deireadh\s+Fomhair|Samhain|Nollaig)"
+)
+DATE_OF_BIRTH_RE = re.compile(
+    rf"(?i)^(?:\d{{1,2}}[./-]\d{{1,2}}[./-]\d{{2,4}}|\d{{4}}-\d{{2}}-\d{{2}}|(?:an\s+)?\d{{1,2}}(?:st|nd|rd|th|ú)?\s+{MONTH_NAME_RE}[,]?\s+\d{{2,4}}|{MONTH_NAME_RE}\s+\d{{1,2}},?\s+\d{{2,4}})$"
+)
+DATE_OF_BIRTH_VALUE_RE = re.compile(
+    rf"(?<![A-Za-z0-9])(\d{{1,2}}[./-]\d{{1,2}}[./-]\d{{2,4}}|\d{{4}}-\d{{2}}-\d{{2}}|(?:an\s+)?\d{{1,2}}(?:st|nd|rd|th|ú)?\s+{MONTH_NAME_RE}[,]?\s+\d{{2,4}}|{MONTH_NAME_RE}\s+\d{{1,2}},?\s+\d{{2,4}})(?![A-Za-z0-9])"
+)
+AGE_CONTEXT_RE = re.compile(r"(?i)\b(age|aged|years?\s+old|year\s+old|year-old|yrs?\s+old|y/?o|yo|aois|bliana\s+d['’]aois|mbliana\s+d['’]aois)\b")
+AGE_INLINE_SUFFIX_RE = re.compile(r"(?i)^(?:-year-old\b|yo\b|y/o\b|yrs?\b)")
+AGE_VALUE_RE = re.compile(r"(?<![A-Za-z0-9])(\d{1,3})(?![A-Za-z0-9])")
+AGE_SELF_PREFIX_RE = re.compile(r"(?i)(?:^|.*\b)(?:i\s+am|i['’]?m|im|t[áa]\s+m[ée]|t[áa]im)\s*$")
+DOB_CONTEXT_RE = re.compile(
+    r"(?i)\b(dob|date\s+of\s+birth|born(?:\s+on)?|data\s+breithe|dáta\s+breithe|dhata\s+breithe|dháta\s+breithe|rugadh)\b"
+)
+ADDRESS_FIELD_CUE_PATTERN = r"(?:address(?:\s+line\s+\d+)?(?:\s+is)?|my\s+address\s+is|seoladh(?:\s+l[ií]nte?\s+\d+)?|is\s+[ée]\s+mo\s+sheoladh)"
+ADDRESS_LINE_CUE_RE = re.compile(r"(?i)\b(?:address\s+line\s+\d+|seoladh\s+l[ií]nte?\s+\d+)\b")
+ADDRESS_CUE_RE = re.compile(
+    rf"(?i)\b({ADDRESS_FIELD_CUE_PATTERN}|sheoladh|allocation\s+centre|intreo\s+centre|ionad\s+leithdh[aá]ilte|ionad\s+intreo|live\s+at|lives\s+at|living\s+at|located\s+at|i\s+mo\s+ch[oó]na[ií]\s+ag|t[áa]\s+m[ée]\s+i\s+mo\s+ch[oó]na[ií]\s+ag|t[áa]im\s+i\s+mo\s+ch[oó]na[ií]\s+ag|cónai\s+ag|chónai\s+ag|conai\s+ag|chonai\s+ag)\b"
+)
+CITY_COUNTY_PREFIX_RE = re.compile(r"(?i)(?:county|co\.|contae|gcontae)(?:\s+na)?\s*$")
+PPSN_CUE_RE = re.compile(
+    r"(?i)\b(ppsn|upsp|personal public service(?:\s+number)?|uimhir\s+(?:mo\s+)?upsp|uimhir\s+(?:mo\s+)?ppsn)\b"
+)
+NAME_STOP_SURFACES = {
+    normalize_surface(value)
+    for value in {
+        "Address",
+        "Name",
+        "Phone",
+        "Email",
+        "Seoladh",
+        "Ainm",
+        "Teagmháil",
+        "Teagmhail",
+        "Ríomhphost",
+        "Riomhphost",
+        "Eirchód",
+        "Eirchod",
+        "Eircode",
+        "PPSN",
+        "UPSP",
+        "Call",
+        "Glao",
+        "Glaoigh",
+        "Rugadh",
+        "Ionad",
+        "Intreo",
+        "Cill",
+        "Sampla",
+        "Leithdháilte",
+        "Leithdhailte",
+        "Leithdháil",
+        "Leithdhail",
+        "Leithdh",
+        "Apartment",
+        "Flat",
+        "Unit",
+        "Suite",
+        "Árasán",
+        "Arasan",
+        "Aonad",
+        "County",
+        "Contae",
+        "Fón",
+        "Fon",
+        "January",
+        "February",
+        "March",
+        "April",
+        "May",
+        "June",
+        "July",
+        "August",
+        "September",
+        "October",
+        "November",
+        "December",
+        "Monday",
+        "Tuesday",
+        "Wednesday",
+        "Thursday",
+        "Friday",
+        "Saturday",
+        "Sunday",
+        "Eanáir",
+        "Feabhra",
+        "Márta",
+        "Aibreán",
+        "Aibrean",
+        "Bealtaine",
+        "Meitheamh",
+        "Iúil",
+        "Iuil",
+        "Lúnasa",
+        "Lunasa",
+        "Meán Fómhair",
+        "Mean Fomhair",
+        "Deireadh Fómhair",
+        "Deireadh Fomhair",
+        "Samhain",
+        "Nollaig",
+        "Luan",
+        "Máirt",
+        "Mairt",
+        "Céadaoin",
+        "Ceadaoin",
+        "Déardaoin",
+        "Deardaoin",
+        "Aoine",
+        "Satharn",
+        "Domhnach",
+    }
+}
+NAME_PARTICLE_SURFACES = {
+    normalize_surface(value)
+    for value in {"Ó", "O", "Ní", "Ni", "Nic", "Mac", "Mc", "de", "van", "von"}
+}
+STREET_TRAILING_BLOCK_SURFACES = {
+    normalize_surface(value)
+    for value in {
+        "are",
+        "public",
+        "contact",
+        "details",
+        "website",
+        "open",
+        "before",
+        "visiting",
+        "roimh",
+        "chuairt",
+        "agus",
+        "and",
+        "the",
+        "is",
+        "ta",
+    }
+}
+ADDRESS_UNIT_PREFIX_RE = re.compile(r"(?i)^(?:apartment|apt\.?|flat|unit|suite|[AaÁá]ras[aá]n|aonad)\b")
+HOUSE_NAME_PREFIX_RE = re.compile(
+    r"(?i)^(?:[A-ZÁÉÍÓÚ][\w'’.-]+(?:\s+[A-ZÁÉÍÓÚ][\w'’.-]+){0,2}\s+(?:house|cottage|lodge|villa)|teach(?:ín|in)?(?:\s+na\s+[A-ZÁÉÍÓÚ][\w'’.-]+)?)$"
+)
+STREET_ADDRESS_VALUE_RE = re.compile(
+    r"(?i)(?<![\w@])("
+    r"(?:(?:apartment|apt\.?|flat|unit|suite|[AaÁá]ras[aá]n|aonad)\s+[A-Za-z0-9-]+,\s+)?"
+    r"(?:(?:[A-ZÁÉÍÓÚ][\w'’.-]+(?:\s+[A-ZÁÉÍÓÚ][\w'’.-]+){0,2}\s+(?:house|cottage|lodge|villa)|teach(?:ín|in)?(?:\s+na\s+[A-ZÁÉÍÓÚ][\w'’.-]+)?),\s+)?"
+    r"(?:\d{1,4}\s+)?(?:[A-ZÁÉÍÓÚa-záéíóú][\w'’.-]*\s+){0,5}(?:street|road|avenue|lane|park|view|square|terrace|drive|close|way|place|crescent|grove|green|court|manor|mews|gardens?|heights|quay|bóthar|bothar|sráid|sraid|lána|lana)(?:\s+[A-ZÁÉÍÓÚa-záéíóú][\w'’.-]*){0,2}"
+    r")"
+)
+
+
+def is_plausible_last_name_sequence(value: str) -> bool:
+    tokens = [token for token in re.split(r"\s+", value.strip()) if token]
+    if not tokens:
+        return False
+    for token in tokens:
+        if not any(ch.isalpha() for ch in token):
+            return False
+        if not all(is_name_token_char(ch) for ch in token):
+            return False
+        alpha_chars = [ch for ch in token if ch.isalpha()]
+        first_alpha = alpha_chars[0] if alpha_chars else ""
+        if first_alpha.isupper():
+            continue
+        if len(alpha_chars) >= 2 and alpha_chars[0].islower() and alpha_chars[1].isupper():
+            continue
+        if normalize_surface(token) in NAME_PARTICLE_SURFACES:
+            continue
+        return False
+    return True
+
+
+def is_reasonable_span_text(label: str, text: str, start: int, end: int) -> bool:
+    value = text[int(start) : int(end)].strip()
+    if not value:
+        return False
+    upper = alnum_upper(value)
+
+    if label in {"FIRST_NAME", "LAST_NAME"}:
+        if not any(ch.isalpha() for ch in value):
+            return False
+        if any(ch.isdigit() for ch in value):
+            return False
+        if int(start) > 0 and text[int(start) - 1].isalpha():
+            return False
+        if int(end) < len(text) and text[int(end)].isalpha():
+            return False
+        if normalize_surface(value) in NAME_STOP_SURFACES:
+            return False
+        if label == "FIRST_NAME" and any(ch.isspace() for ch in value):
+            return False
+        if any(ch in ".,;:/@()" for ch in value):
+            return False
+        if label == "FIRST_NAME":
+            first_alpha = next((ch for ch in value if ch.isalpha()), "")
+            if not first_alpha or not first_alpha.isupper():
+                return False
+        if label == "LAST_NAME" and not is_plausible_last_name_sequence(value):
+            return False
+        if start > 0 and text[int(start) - 1].isdigit():
+            return False
+        return True
+
+    if label == "EMAIL":
+        if "@" not in value:
+            return False
+        local, _, domain = value.partition("@")
+        return bool(local) and "." in domain
+
+    if label == "PHONE_NUMBER":
+        normalized = value.replace("\u00A0", " ").replace("\u202F", " ").strip()
+        if any(ch.isalpha() for ch in normalized):
+            return False
+        if "@" in normalized:
+            return False
+        if int(start) > 0 and text[int(start) - 1].isalnum():
+            return False
+        if int(end) < len(text) and text[int(end)].isalnum():
+            return False
+        if not PHONE_SURFACE_RE.match(normalized):
+            return False
+        digits = "".join(ch for ch in value if ch.isdigit())
+        if normalized.startswith("+353"):
+            tail = digits[3:]
+            if tail.startswith("0"):
+                tail = tail[1:]
+            return 8 <= len(tail) <= 9
+        if not digits.startswith("0"):
+            return False
+        if digits.startswith("0818") or digits.startswith("1800"):
+            return len(digits) == 10
+        if digits.startswith("08"):
+            return len(digits) == 10
+        if digits.startswith("01"):
+            return len(digits) == 9
+        return 9 <= len(digits) <= 10
+
+    if label == "PPSN":
+        return bool(len(upper) in {8, 9} and upper[:7].isdigit() and upper[7:].isalpha())
+
+    if label == "POSTCODE":
+        compact = value.replace(" ", "").replace("\u00A0", "").replace("\u202F", "")
+        if any(not (ch.isalnum() or ch.isspace()) for ch in value):
+            return False
+        if len(compact) != 7:
+            return False
+        routing = compact[:3]
+        unique = compact[3:]
+        routing_ok = bool(
+            (routing[0].isalpha() and routing[1:].isdigit())
+            or routing == "D6W"
+        )
+        unique_ok = bool(
+            len(unique) == 4
+            and unique[0].isalpha()
+            and unique[1:].isalnum()
+        )
+        return routing_ok and unique_ok
+
+    if label == "PASSPORT_NUMBER":
+        return bool(re.fullmatch(r"[A-Z]{1,2}\s?\d{7}", value.strip()))
+
+    if label == "BANK_ROUTING_NUMBER":
+        digits = "".join(ch for ch in value if ch.isdigit())
+        if len(digits) != 6:
+            return False
+        context = text[max(0, int(start) - 32) : min(len(text), int(end) + 24)]
+        return bool(BANK_ROUTING_CONTEXT_RE.search(context))
+
+    if label == "SWIFT_BIC":
+        return len(upper) in {8, 11} and upper.isalnum()
+
+    if label == "CREDIT_DEBIT_CARD":
+        digits = "".join(ch for ch in value if ch.isdigit())
+        return 12 <= len(digits) <= 19
+
+    if label == "ACCOUNT_NUMBER":
+        if upper.startswith("IE"):
+            return bool(re.fullmatch(r"IE\d{2}[A-Z0-9]{18}", upper))
+        if not ACCOUNT_DIGIT_SURFACE_RE.fullmatch(value.strip()):
+            return False
+        digits = "".join(ch for ch in value if ch.isdigit())
+        return 6 <= len(digits) <= 34
+
+    if label == "AGE":
+        digits = "".join(ch for ch in value if ch.isdigit())
+        if digits != value.strip():
+            return False
+        if not digits:
+            return False
+        if int(start) > 0 and text[int(start) - 1].isalnum():
+            return False
+        trailing = text[int(end) : min(len(text), int(end) + 12)]
+        if int(end) < len(text) and text[int(end)].isalnum() and not AGE_INLINE_SUFFIX_RE.match(trailing):
+            return False
+        if int(start) > 0 and text[int(start) - 1] in "/-":
+            return False
+        if int(end) < len(text) and text[int(end)] in "/-" and not AGE_INLINE_SUFFIX_RE.match(trailing):
+            return False
+        age = int(digits)
+        if not (0 < age <= 120):
+            return False
+        context = text[max(0, int(start) - 32) : min(len(text), int(end) + 24)]
+        prefix = text[max(0, int(start) - 24) : int(start)]
+        return bool(AGE_CONTEXT_RE.search(context) or AGE_SELF_PREFIX_RE.search(prefix))
+
+    if label == "DATE_OF_BIRTH":
+        if not any(ch.isdigit() for ch in value):
+            return False
+        if not DATE_OF_BIRTH_RE.match(value.strip()):
+            return False
+        context = text[max(0, int(start) - 32) : min(len(text), int(end) + 32)]
+        return bool(DOB_CONTEXT_RE.search(context))
+
+    if label == "CITY":
+        if any(ch.isdigit() for ch in value):
+            return False
+        prefix = text[max(0, int(start) - 20) : int(start)]
+        if CITY_COUNTY_PREFIX_RE.search(prefix):
+            return False
+        return normalize_surface(value) in IRISH_CITY_SURFACES
+
+    if label == "COUNTY":
+        if any(ch.isdigit() for ch in value):
+            return False
+        normalized = normalize_surface(value)
+        return normalized in IRISH_COUNTY_SURFACES or normalized.startswith(("county ", "contae ", "gcontae ", "co. "))
+
+    if label == "STREET_ADDRESS":
+        cleaned = value.strip()
+        address_parts = [part.strip() for part in cleaned.split(",")]
+        if len(address_parts) > 2:
+            return False
+        prefix_part = ""
+        street_part = cleaned
+        if len(address_parts) == 2:
+            prefix_part, street_part = address_parts
+            if not prefix_part or not street_part:
+                return False
+            if not (
+                ADDRESS_UNIT_PREFIX_RE.match(prefix_part)
+                or HOUSE_NAME_PREFIX_RE.match(prefix_part)
+            ):
+                return False
+        suffix_match = STREET_SUFFIX_RE.search(street_part)
+        if not suffix_match:
+            return False
+        if any(ch in "@:;" for ch in cleaned):
+            return False
+        trailing = street_part[int(suffix_match.end()) :].strip()
+        trailing_tokens = [token for token in re.split(r"\s+", trailing) if token]
+        if len(trailing_tokens) > 3:
+            return False
+        if any(normalize_surface(token) in STREET_TRAILING_BLOCK_SURFACES for token in trailing_tokens):
+            return False
+        has_digit = any(ch.isdigit() for ch in street_part)
+        if has_digit and not re.match(r"^\s*\d{1,4}\b", street_part):
+            return False
+        title_tokens = [token for token in re.split(r"\s+", street_part) if token]
+        if not has_digit and not prefix_part:
+            context = text[max(0, int(start) - 24) : min(len(text), int(end) + 12)]
+            if not ADDRESS_CUE_RE.search(context):
+                return False
+        return has_digit or len(title_tokens) >= 2
+
+    return True
+
+
+def spans_overlap(a: dict, b: dict) -> bool:
+    return int(a["start"]) < int(b["end"]) and int(b["start"]) < int(a["end"])
+
+
+def is_name_token_char(ch: str) -> bool:
+    return ch.isalpha() or ch in {"-", "'", "’"}
+
+
+def is_plausible_first_name(value: str) -> bool:
+    if not value:
+        return False
+    if any(ch.isspace() for ch in value):
+        return False
+    if any(ch.isdigit() for ch in value):
+        return False
+    if any(ch in ",;:/@()" for ch in value):
+        return False
+    if not any(ch.isalpha() for ch in value):
+        return False
+    first_alpha = next((ch for ch in value if ch.isalpha()), "")
+    if not first_alpha or not first_alpha.isupper():
+        return False
+    return all(is_name_token_char(ch) for ch in value)
+
+
+def is_plausible_cued_first_name(value: str) -> bool:
+    if not value:
+        return False
+    if any(ch.isspace() for ch in value):
+        return False
+    if any(ch.isdigit() for ch in value):
+        return False
+    if any(ch in ",;:/@()" for ch in value):
+        return False
+    if not any(ch.isalpha() for ch in value):
+        return False
+    return all(is_name_token_char(ch) for ch in value)
+
+
+def is_plausible_cued_last_name_sequence(value: str) -> bool:
+    tokens = [token for token in re.split(r"\s+", value.strip()) if token]
+    if not tokens:
+        return False
+    for token in tokens:
+        if not any(ch.isalpha() for ch in token):
+            return False
+        if not all(is_name_token_char(ch) for ch in token):
+            return False
+        alpha_chars = [ch for ch in token if ch.isalpha()]
+        first_alpha = alpha_chars[0] if alpha_chars else ""
+        if first_alpha.isupper() or first_alpha.islower():
+            continue
+        if normalize_surface(token) in NAME_PARTICLE_SURFACES:
+            continue
+        return False
+    return True
+
+
+def extract_name_tokens_after_cue(text: str, cue_end: int, max_tokens: int = 4) -> list[tuple[int, int, str]]:
+    cursor = cue_end
+    while cursor < len(text) and text[cursor].isspace():
+        cursor += 1
+    tokens: list[tuple[int, int, str]] = []
+    while cursor < len(text):
+        while cursor < len(text) and text[cursor].isspace():
+            cursor += 1
+        if cursor >= len(text) or text[cursor] in ",.;:\n":
+            break
+        token_start = cursor
+        while cursor < len(text) and is_name_token_char(text[cursor]):
+            cursor += 1
+        if token_start == cursor:
+            break
+        token = text[token_start:cursor]
+        normalized = normalize_surface(token)
+        if tokens and normalized in NAME_CUE_STOP_SURFACES:
+            break
+        if not all(is_name_token_char(ch) for ch in token):
+            break
+        tokens.append((token_start, cursor, token))
+        if len(tokens) >= max_tokens:
+            break
+        if cursor < len(text) and text[cursor] in ",.;:\n":
+            break
+        if cursor < len(text) and not text[cursor].isspace():
+            break
+    return tokens
+
+
+def repair_first_name_from_last_name(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for last_name in [span for span in repaired if span["label"] == "LAST_NAME"]:
+        if any(
+            span["label"] == "FIRST_NAME"
+            and int(span["end"]) <= int(last_name["start"])
+            and int(last_name["start"]) - int(span["end"]) <= 2
+            for span in repaired
+        ):
+            continue
+
+        cursor = int(last_name["start"]) - 1
+        if cursor < 0 or not text[cursor].isspace():
+            continue
+        while cursor >= 0 and text[cursor].isspace():
+            cursor -= 1
+        token_end = cursor + 1
+        while cursor >= 0 and is_name_token_char(text[cursor]):
+            cursor -= 1
+        token_start = cursor + 1
+        if token_end <= token_start:
+            continue
+        candidate = text[token_start:token_end]
+        if not is_plausible_first_name(candidate):
+            continue
+        candidate_span = {
+            "start": token_start,
+            "end": token_end,
+            "label": "FIRST_NAME",
+            "score": float(last_name.get("score", 0.5)) * 0.6,
+            "text": candidate,
+        }
+        if any(spans_overlap(candidate_span, other) for other in repaired if other["label"] == "FIRST_NAME"):
+            continue
+        repaired.append(candidate_span)
+    return repaired
+
+
+def repair_contextual_name_cues(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for match in NAME_SELF_CUE_RE.finditer(text):
+        if any(
+            other["label"] == "FIRST_NAME"
+            and 0 <= int(other["start"]) - match.end() <= 4
+            for other in repaired
+        ) and any(
+            other["label"] == "LAST_NAME"
+            and 0 <= int(other["start"]) - match.end() <= 16
+            for other in repaired
+        ):
+            continue
+        cursor = match.end()
+        while cursor < len(text) and text[cursor].isspace():
+            cursor += 1
+        start = cursor
+        while cursor < len(text) and (is_name_token_char(text[cursor]) or text[cursor].isspace()):
+            cursor += 1
+        candidate = text[start:cursor].strip()
+        raw_tokens = [token for token in re.split(r"\s+", candidate) if token]
+        tokens: list[str] = []
+        for token in raw_tokens:
+            normalized = normalize_surface(token)
+            if tokens and normalized in LOWER_NAME_STOP_SURFACES:
+                break
+            if not all(is_name_token_char(ch) for ch in token):
+                break
+            tokens.append(token)
+            if len(tokens) >= 4:
+                break
+        if len(tokens) < 2:
+            continue
+        first_value = tokens[0]
+        last_value = " ".join(tokens[1:])
+        if not is_plausible_cued_first_name(first_value):
+            continue
+        if not is_plausible_cued_last_name_sequence(last_value):
+            continue
+        first_start = text.find(first_value, start, cursor)
+        if first_start < 0:
+            continue
+        first_end = first_start + len(first_value)
+        last_start = text.find(last_value, first_end, cursor)
+        if last_start < 0:
+            continue
+        last_end = last_start + len(last_value)
+        first_span = {
+            "start": first_start,
+            "end": first_end,
+            "label": "FIRST_NAME",
+            "score": 0.63,
+            "text": text[first_start:first_end],
+        }
+        last_span = {
+            "start": last_start,
+            "end": last_end,
+            "label": "LAST_NAME",
+            "score": 0.63,
+            "text": text[last_start:last_end],
+        }
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(first_span, other) and other["label"] in {"FIRST_NAME", "LAST_NAME"}
+            ) and not (
+                spans_overlap(last_span, other) and other["label"] in {"FIRST_NAME", "LAST_NAME"}
+            )
+        ]
+        repaired.extend([first_span, last_span])
+    return repaired
+
+
+def repair_role_name_cues(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for match in NAME_ROLE_CUE_RE.finditer(text):
+        token_bounds = extract_name_tokens_after_cue(text, match.end())
+        if len(token_bounds) < 2:
+            continue
+        first_start, first_end, first_value = token_bounds[0]
+        last_start = token_bounds[1][0]
+        last_end = token_bounds[-1][1]
+        last_value = text[last_start:last_end]
+        if not is_plausible_cued_first_name(first_value):
+            continue
+        if not is_plausible_cued_last_name_sequence(last_value):
+            continue
+        first_span = {
+            "start": first_start,
+            "end": first_end,
+            "label": "FIRST_NAME",
+            "score": 0.63,
+            "text": text[first_start:first_end],
+        }
+        last_span = {
+            "start": last_start,
+            "end": last_end,
+            "label": "LAST_NAME",
+            "score": 0.63,
+            "text": text[last_start:last_end],
+        }
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(first_span, other) and other["label"] in {"FIRST_NAME", "LAST_NAME"}
+            ) and not (
+                spans_overlap(last_span, other) and other["label"] in {"FIRST_NAME", "LAST_NAME"}
+            )
+        ]
+        repaired.extend([first_span, last_span])
+    return repaired
+
+
+def repair_surname_field_cues(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for match in SURNAME_CUE_RE.finditer(text):
+        token_bounds = extract_name_tokens_after_cue(text, match.end())
+        if not token_bounds:
+            continue
+        start = token_bounds[0][0]
+        end = token_bounds[-1][1]
+        candidate = text[start:end]
+        if not is_plausible_cued_last_name_sequence(candidate):
+            continue
+        last_span = {
+            "start": start,
+            "end": end,
+            "label": "LAST_NAME",
+            "score": 0.64,
+            "text": candidate,
+        }
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(last_span, other) and other["label"] in {"FIRST_NAME", "LAST_NAME"}
+            )
+        ]
+        repaired.append(last_span)
+    return repaired
+
+
+def repair_name_particle_surnames(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    surname_re = re.compile(
+        r"^\s*((?:Ní|Ni|Ó|O|Nic|Mac|Mc)\s+[A-ZÁÉÍÓÚ][A-Za-zÁÉÍÓÚáéíóú'’-]*(?:\s+[A-ZÁÉÍÓÚ][A-Za-zÁÉÍÓÚáéíóú'’-]*)?)"
+    )
+    first_names = [span for span in repaired if span["label"] == "FIRST_NAME"]
+    for first_name in first_names:
+        tail = text[int(first_name["end"]) : min(len(text), int(first_name["end"]) + 40)]
+        match = surname_re.match(tail)
+        if not match:
+            continue
+        start = int(first_name["end"]) + int(match.start(1))
+        end = int(first_name["end"]) + int(match.end(1))
+        candidate = text[start:end]
+        if not is_plausible_cued_last_name_sequence(candidate):
+            continue
+        candidate_span = {
+            "start": start,
+            "end": end,
+            "label": "LAST_NAME",
+            "score": 0.66,
+            "text": candidate,
+        }
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(candidate_span, other)
+                and other["label"] in {"FIRST_NAME", "LAST_NAME"}
+            )
+        ]
+        repaired.append(candidate_span)
+    return repaired
+
+
+def repair_name_before_structured_cues(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for match in NAME_BEFORE_STRUCTURED_CUE_RE.finditer(text):
+        token_bounds = extract_name_tokens_after_cue(text, match.start(1))
+        if len(token_bounds) < 2:
+            continue
+        first_start, first_end, first_value = token_bounds[0]
+        last_start = token_bounds[1][0]
+        last_end = token_bounds[-1][1]
+        last_value = text[last_start:last_end]
+        if not is_plausible_first_name(first_value):
+            continue
+        if not is_plausible_last_name_sequence(last_value):
+            continue
+        first_span = {
+            "start": first_start,
+            "end": first_end,
+            "label": "FIRST_NAME",
+            "score": 0.64,
+            "text": text[first_start:first_end],
+        }
+        last_span = {
+            "start": last_start,
+            "end": last_end,
+            "label": "LAST_NAME",
+            "score": 0.64,
+            "text": text[last_start:last_end],
+        }
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(first_span, other) and other["label"] in {"FIRST_NAME", "LAST_NAME"}
+            ) and not (
+                spans_overlap(last_span, other) and other["label"] in {"FIRST_NAME", "LAST_NAME"}
+            )
+        ]
+        repaired.extend([first_span, last_span])
+    return repaired
+
+
+PASSPORT_CUE_RE = re.compile(
+    r"(?i)(passport(?:\s+number)?|phas|uimhir\s+(?:mo\s+)?phas)"
+)
+PASSPORT_VALUE_RE = re.compile(r"(?<![A-Za-z0-9])([A-Z]{1,2}\s?\d{7})(?![A-Za-z0-9])")
+EMAIL_EXTRACT_RE = re.compile(r"([^\s@,;:()<>]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,})", re.UNICODE)
+PHONE_CUE_RE = re.compile(
+    r"(?i)\b(phone|call|contact|reach\s+me|glaoigh\s+ar|teagmh[aá]il|uimhir|m['’]uimhir|f[oó]n|fon|teileaf[oó]n|telefon)\b"
+)
+NAME_SELF_CUE_RE = re.compile(
+    r"(?i)\b(my\s+name\s+is|is\s+mise|is\s+[ée]\s+m['’]?ainm|is\s+[ée]\s+mo\s+ainm)\b"
+)
+NAME_ROLE_CUE_RE = re.compile(
+    r"(?i)(?:\b(?:applicant|customer|claimant|patient|an\s+t-iarratas[oó]ir|iarratas[oó]ir)\b\s*[:,]\s*|\b(?:full\s+name|name|ainm(?!\s+teaghlaigh))\b\s*:\s*)"
+)
+SURNAME_CUE_RE = re.compile(
+    r"(?i)\b(?:my\s+)?(?:surname|last\s+name|family\s+name|ainm\s+teaghlaigh|sloinne)\b(?:\s+is)?\s*[:,-]?\s*"
+)
+NAME_PARTICLE_SURNAME_RE = re.compile(r"(?i)(?:\bN[ií]\b|\bÓ\b|\bNic\b|\bMac\b|\bMc\b|\bO['’])")
+NAME_BEFORE_STRUCTURED_CUE_RE = re.compile(
+    r"(?<![A-Za-zÁÉÍÓÚáéíóú])([A-ZÁÉÍÓÚ][A-Za-zÁÉÍÓÚáéíóú'’.-]*(?:\s+[A-ZÁÉÍÓÚ][A-Za-zÁÉÍÓÚáéíóú'’.-]*){1,3})(?=\s*,\s*(?:PPSN|UPSP|DOB|Date\s+of\s+birth|D[áa]ta\s+breithe|Address|Seoladh|lives?\s+at|my\s+phone|phone|email|r-phost))"
+)
+LOWER_NAME_STOP_SURFACES = {
+    normalize_surface(value)
+    for value in {"and", "agus", "is", "ta", "tá", "my", "mo", "an", "the"}
+}
+NAME_CUE_STOP_SURFACES = {
+    normalize_surface(value)
+    for value in {
+        "and",
+        "agus",
+        "submitted",
+        "provided",
+        "gave",
+        "her",
+        "his",
+        "their",
+        "she",
+        "he",
+        "email",
+        "phone",
+        "fón",
+        "fon",
+        "ppsn",
+        "upsp",
+        "address",
+        "seoladh",
+        "dob",
+        "age",
+        "aois",
+        "bank",
+        "iban",
+        "swift",
+        "chuir",
+        "isteach",
+        "sí",
+        "si",
+        "a",
+        "huimhir",
+    }
+}
+ORG_NAME_TRAILING_SURFACES = {
+    normalize_surface(value)
+    for value in {"centre", "center", "clinic", "hospital", "office", "service", "section", "unit", "council"}
+}
+ORG_CITY_TAIL_RE = re.compile(
+    r"(?i)^\s+(?:intreo\s+centre|business\s+centre|community\s+centre|shopping\s+centre|retail\s+park|p[áa]irc\s+miond[ií]ola)\b"
+)
+ORG_NAME_PREFIX_RE = re.compile(
+    r"(?i)(?:retail\s+park|business\s+centre|community\s+centre|shopping\s+centre|p[áa]irc\s+miond[ií]ola)\s*$"
+)
+PUBLIC_CONTACT_DETAILS_RE = re.compile(r"(?i)\bpublic\s+contact\s+details\b")
+CITY_CUE_RE = re.compile(
+    r"(?i)\b(address|seoladh|located|suite|centre|center|ionad|intreo|clinic|hospital|ospid[eé]al|hse|fss)\b"
+)
+BANK_ROUTING_CONTEXT_RE = re.compile(
+    r"(?i)\b(sort\s+code|routing\s+number|bank\s+of\s+ireland|aib|cod\s+sort[aá]la|sort[aá]la)\b"
+)
+PHONE_VALUE_RE = re.compile(
+    r"(?<![A-Za-z0-9])((?:\+353(?:\s*\((?:0)?\d{1,2}\))?[\s\-./]?|0)\d(?:[\s\-./]?\d){6,13}|\(\s*0\d{1,2}\s*\)(?:[\s\-./]?\d){6,10})(?![A-Za-z0-9])"
+)
+PPSN_VALUE_RE = re.compile(r"(?<![A-Za-z0-9])(\d{7}(?:[\s-]*[A-Za-z]){1,2})(?![A-Za-z0-9])")
+POSTCODE_VALUE_RE = re.compile(
+    r"(?<![A-Za-z0-9])((?:[A-Za-z]\d{2}|D6W)[\s\u00A0\u202F]?[A-Za-z][A-Za-z0-9]{3})(?![A-Za-z0-9])"
+)
+CITY_BEFORE_POSTCODE_RE = re.compile(
+    r"(?<![A-Za-zÁÉÍÓÚáéíóú])([A-ZÁÉÍÓÚ][\w'’.-]*(?:\s+[A-ZÁÉÍÓÚ][\w'’.-]*){0,2})(?=\s*,\s*(?:(?:County|Contae|gContae|Co\.)\s+[A-ZÁÉÍÓÚ][\w'’.-]*(?:\s+[A-ZÁÉÍÓÚ][\w'’.-]*){0,2}\s*,\s*)?(?:[A-Z]\d{2}|D6W))"
+)
+CITY_BEFORE_COUNTY_RE = re.compile(
+    r"(?<![A-Za-zÁÉÍÓÚáéíóú])([A-ZÁÉÍÓÚ][\w'’.-]*(?:\s+[A-ZÁÉÍÓÚ][\w'’.-]*){0,3})(?=\s*,\s*(?:County|Contae|gContae|Co\.)\s+[A-ZÁÉÍÓÚ][\w'’.-]*(?:\s+[A-ZÁÉÍÓÚ][\w'’.-]*){0,2}\b)"
+)
+CITY_TOWN_SUFFIX_RE = re.compile(
+    r"(?<![A-Za-zÁÉÍÓÚáéíóú])([A-ZÁÉÍÓÚ][\w'’.-]*(?:\s+[A-ZÁÉÍÓÚ][\w'’.-]*){0,2}\s+Town)(?=\s*,\s*(?:(?:County|Contae|gContae|Co\.)\s+[A-ZÁÉÍÓÚ][\w'’.-]*(?:\s+[A-ZÁÉÍÓÚ][\w'’.-]*){0,2}\s*,\s*)?(?:[A-Z]\d{2}|D6W))"
+)
+CITY_FIELD_VALUE_RE = re.compile(
+    r"(?im)(?:^|[\n\r])\s*(?:city(?:/town)?|town|cathair|baile)\b\s*[:,-]?\s*([A-ZÁÉÍÓÚ][A-Za-zÁÉÍÓÚáéíóú'’-]*(?:\s+[A-ZÁÉÍÓÚ][A-Za-zÁÉÍÓÚáéíóú'’-]*){0,3})"
+)
+INLINE_CITY_FIELD_VALUE_RE = re.compile(
+    r"(?i)\b(?:city(?:/town)?|cathair|baile)\b\s*[:,-]\s*([A-ZÁÉÍÓÚ][A-Za-zÁÉÍÓÚáéíóú'’-]*(?:\s+[A-ZÁÉÍÓÚ][A-Za-zÁÉÍÓÚáéíóú'’-]*){0,3})"
+)
+COUNTY_FIELD_VALUE_RE = re.compile(
+    r"(?im)(?:^|[\n\r])\s*(?:county|co\.|contae|gcontae)\b\s*[:,-]?\s*((?:Co\.\s+)?[A-ZÁÉÍÓÚ][A-Za-zÁÉÍÓÚáéíóú'’-]*(?:\s+[A-ZÁÉÍÓÚ][A-Za-zÁÉÍÓÚáéíóú'’-]*){0,2})"
+)
+INLINE_COUNTY_FIELD_VALUE_RE = re.compile(
+    r"(?i)\b(?:county|co\.|contae|gcontae)\b\s*[:,-]\s*((?:Co\.\s+)?[A-ZÁÉÍÓÚ][A-Za-zÁÉÍÓÚáéíóú'’-]*(?:\s+[A-ZÁÉÍÓÚ][A-Za-zÁÉÍÓÚáéíóú'’-]*){0,2})"
+)
+COUNTY_VALUE_RE = re.compile(
+    r"(?<![A-Za-zÁÉÍÓÚáéíóú])((?:County|Contae|gContae|Co\.)(?:\s+[A-ZÁÉÍÓÚ][A-Za-zÁÉÍÓÚáéíóú'’-]*){1,3})(?![A-Za-zÁÉÍÓÚáéíóú])"
+)
+ADDRESS_BLOCK_VALUE_RE = re.compile(
+    rf"(?i)\b(?:{ADDRESS_FIELD_CUE_PATTERN}|live\s+at|lives\s+at|living\s+at|located\s+at|t[áa]\s+m[ée]\s+i\s+mo\s+ch[oó]na[ií]\s+ag|t[áa]im\s+i\s+mo\s+ch[oó]na[ií]\s+ag)\b\s*[:,-]?\s*([^,\n.]+)"
+)
+ADDRESS_PLACE_VALUE_RE = re.compile(
+    rf"(?i)\b(?:{ADDRESS_FIELD_CUE_PATTERN}|live\s+at|lives\s+at|living\s+at|located\s+at|allocation\s+centre|intreo\s+centre)\b\s*[:,-]?\s*("
+    r"(?:(?:apartment|apt\.?|flat|unit|suite|[AaÁá]ras[aá]n|aonad)\s+[A-Za-z0-9-]+,\s+)?"
+    r"(?:[A-ZÁÉÍÓÚ][\w'’.-]*(?:\s+[A-ZÁÉÍÓÚ][\w'’.-]*){0,4}\s+(?:business\s+centre|community\s+centre|shopping\s+centre|retail\s+park)|P[áa]irc\s+Miond[ií]ola(?:\s+[A-ZÁÉÍÓÚ][\w'’.-]*)?)"
+    r")"
+)
+ADDRESS_BUILDING_TAIL_RE = re.compile(
+    r"^\s*,\s*((?:[A-ZÁÉÍÓÚa-záéíóú][\w'’.-]*\s+){0,5}(?:house|cottage|lodge|villa|apartments?|building|business\s+centre|community\s+centre|shopping\s+centre|retail\s+park)|Teach(?:ín|in)?(?:\s+na\s+[A-ZÁÉÍÓÚa-záéíóú][\w'’.-]+)?)",
+    flags=re.IGNORECASE,
+)
+LOCATION_FORM_EDGE = r"[A-Za-zÁÉÍÓÚáéíóú]"
+
+
+def iter_bounded_form_matches(form: str, text: str):
+    pattern = re.compile(
+        rf"(?<!{LOCATION_FORM_EDGE}){re.escape(form)}(?!{LOCATION_FORM_EDGE})",
+        flags=re.IGNORECASE,
+    )
+    return pattern.finditer(text)
+
+
+def repair_contextual_passport_numbers(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for match in PASSPORT_VALUE_RE.finditer(text):
+        start, end = match.span(1)
+        candidate_span = {
+            "start": start,
+            "end": end,
+            "label": "PASSPORT_NUMBER",
+            "score": 0.67,
+            "text": text[start:end],
+        }
+        if any(
+            other["label"] == "PASSPORT_NUMBER"
+            and int(other["start"]) <= start
+            and int(other["end"]) >= end
+            for other in repaired
+        ):
+            continue
+        cue_window = text[max(0, start - 32) : start]
+        if not PASSPORT_CUE_RE.search(cue_window):
+            continue
+        conflicting_labels = {"PHONE_NUMBER", "PPSN", "ACCOUNT_NUMBER", "AGE", "PASSPORT_NUMBER"}
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(candidate_span, other)
+                and other["label"] in conflicting_labels
+            )
+        ]
+        repaired.append(candidate_span)
+    return repaired
+
+
+def repair_ppsn_variants(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for match in PPSN_VALUE_RE.finditer(text):
+        start, end = match.span(1)
+        value = text[start:end]
+        compact = alnum_upper(value)
+        if not (len(compact) in {8, 9} and compact[:7].isdigit() and compact[7:].isalpha()):
+            continue
+        cue_window = text[max(0, start - 32) : min(len(text), end + 24)]
+        has_cue = bool(PPSN_CUE_RE.search(cue_window))
+        candidate_span = {
+            "start": start,
+            "end": end,
+            "label": "PPSN",
+            "score": 0.72 if has_cue else 0.58,
+            "text": value,
+        }
+        conflicting_labels = {"PHONE_NUMBER", "PASSPORT_NUMBER", "ACCOUNT_NUMBER", "AGE", "FIRST_NAME", "LAST_NAME"}
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(candidate_span, other)
+                and other["label"] in conflicting_labels.union({"PPSN"})
+            )
+        ]
+        repaired.append(candidate_span)
+    return repaired
+
+
+def repair_contextual_date_of_birth(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for match in DATE_OF_BIRTH_VALUE_RE.finditer(text):
+        start, end = match.span(1)
+        cue_window = text[max(0, start - 96) : min(len(text), end + 24)]
+        if not DOB_CONTEXT_RE.search(cue_window):
+            continue
+        candidate_span = {
+            "start": start,
+            "end": end,
+            "label": "DATE_OF_BIRTH",
+            "score": 0.66,
+            "text": text[start:end],
+        }
+        conflicting_labels = {"DATE_OF_BIRTH", "PHONE_NUMBER", "AGE", "FIRST_NAME", "LAST_NAME", "ACCOUNT_NUMBER", "CITY"}
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(candidate_span, other)
+                and other["label"] in conflicting_labels
+            )
+        ]
+        repaired.append(candidate_span)
+    return repaired
+
+
+def repair_contextual_ages(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for match in AGE_VALUE_RE.finditer(text):
+        start, end = match.span(1)
+        if not is_reasonable_span_text("AGE", text, start, end):
+            continue
+        if any(
+            spans_overlap({"start": start, "end": end}, other)
+            and other["label"] == "DATE_OF_BIRTH"
+            for other in repaired
+        ):
+            continue
+        candidate_span = {
+            "start": start,
+            "end": end,
+            "label": "AGE",
+            "score": 0.66,
+            "text": text[start:end],
+        }
+        conflicting_labels = {"AGE", "PHONE_NUMBER", "ACCOUNT_NUMBER"}
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(candidate_span, other)
+                and other["label"] in conflicting_labels
+            )
+        ]
+        repaired.append(candidate_span)
+    return repaired
+
+
+ACCOUNT_CUE_RE = re.compile(
+    r"(?i)(account\s+number|bank\s+account|uimhir\s+chuntais|cuntas\s+bainc)"
+)
+ACCOUNT_VALUE_RE = re.compile(r"(?<![A-Za-z0-9])(\d{6,12})(?![A-Za-z0-9])")
+
+
+def repair_contextual_account_numbers(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for match in ACCOUNT_VALUE_RE.finditer(text):
+        start, end = match.span(1)
+        candidate_span = {
+            "start": start,
+            "end": end,
+            "label": "ACCOUNT_NUMBER",
+            "score": 0.51,
+            "text": text[start:end],
+        }
+        if any(
+            other["label"] == "ACCOUNT_NUMBER"
+            and int(other["start"]) <= start
+            and int(other["end"]) >= end
+            for other in repaired
+        ):
+            continue
+        cue_window = text[max(0, start - 40) : start]
+        if not ACCOUNT_CUE_RE.search(cue_window):
+            continue
+        if any(
+            spans_overlap(candidate_span, other)
+            and other["label"] in {"PHONE_NUMBER", "BANK_ROUTING_NUMBER", "PPSN", "POSTCODE", "PASSPORT_NUMBER"}
+            for other in repaired
+        ):
+            continue
+        repaired.append(candidate_span)
+    return repaired
+
+
+def repair_emails(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for match in EMAIL_EXTRACT_RE.finditer(text):
+        start, end = match.span(1)
+        candidate_span = {
+            "start": start,
+            "end": end,
+            "label": "EMAIL",
+            "score": 0.74,
+            "text": text[start:end],
+        }
+        conflicting_labels = {"EMAIL", "FIRST_NAME", "LAST_NAME"}
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(candidate_span, other)
+                and other["label"] in conflicting_labels
+            )
+        ]
+        repaired.append(candidate_span)
+    return repaired
+
+
+def repair_phone_numbers(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for match in PHONE_VALUE_RE.finditer(text):
+        start, end = match.span(1)
+        candidate_span = {
+            "start": start,
+            "end": end,
+            "label": "PHONE_NUMBER",
+            "score": 0.69,
+            "text": text[start:end],
+        }
+        cue_window = text[max(0, start - 32) : min(len(text), end + 16)]
+        has_cue = bool(PHONE_CUE_RE.search(cue_window))
+        has_overlap = any(spans_overlap(candidate_span, other) and other["label"] == "PHONE_NUMBER" for other in repaired)
+        if not (has_cue or has_overlap):
+            continue
+        if not is_reasonable_span_text("PHONE_NUMBER", text, start, end):
+            continue
+        conflicting_labels = {"PHONE_NUMBER", "PPSN", "ACCOUNT_NUMBER", "BANK_ROUTING_NUMBER", "CREDIT_DEBIT_CARD"}
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(candidate_span, other)
+                and other["label"] in conflicting_labels
+            )
+        ]
+        repaired.append(candidate_span)
+    return repaired
+
+
+def repair_postcodes(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for match in POSTCODE_VALUE_RE.finditer(text):
+        start, end = match.span(1)
+        candidate_span = {
+            "start": start,
+            "end": end,
+            "label": "POSTCODE",
+            "score": 0.71,
+            "text": text[start:end],
+        }
+        conflicting_labels = {"POSTCODE", "PHONE_NUMBER", "ACCOUNT_NUMBER", "FIRST_NAME", "LAST_NAME"}
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(candidate_span, other)
+                and other["label"] in conflicting_labels
+            )
+        ]
+        repaired.append(candidate_span)
+    return repaired
+
+
+def repair_city_spans(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    seen: set[tuple[int, int]] = set()
+    ordered_forms = sorted(IRISH_CITY_FORMS, key=len, reverse=True)
+    for form in ordered_forms:
+        for match in iter_bounded_form_matches(form, text):
+            start, end = match.span()
+            prefix = text[max(0, start - 20) : start]
+            if CITY_COUNTY_PREFIX_RE.search(prefix):
+                continue
+            key = (start, end)
+            if key in seen:
+                continue
+            seen.add(key)
+            candidate_span = {
+                "start": start,
+                "end": end,
+                "label": "CITY",
+                "score": 0.64,
+                "text": text[start:end],
+            }
+            has_context = False
+            for other in repaired:
+                other_start = int(other["start"])
+                other_end = int(other["end"])
+                if other["label"] == "STREET_ADDRESS" and 0 <= start - other_end <= 4:
+                    has_context = True
+                    break
+                if other["label"] in {"COUNTY", "POSTCODE"} and 0 <= other_start - end <= 6:
+                    has_context = True
+                    break
+            if not has_context and re.match(r"^\s*,\s*(?:Co\.\s+|[A-Z]\d{2}|D6W)", text[end:]):
+                has_context = True
+            if not has_context:
+                cue_window = text[max(0, start - 40) : min(len(text), end + 32)]
+                has_context = bool(CITY_CUE_RE.search(cue_window) or ADDRESS_CUE_RE.search(cue_window))
+            if not has_context:
+                continue
+            conflicting_labels = {"CITY", "FIRST_NAME", "LAST_NAME"}
+            repaired = [
+                other
+                for other in repaired
+                if not (
+                    spans_overlap(candidate_span, other)
+                    and other["label"] in conflicting_labels
+                )
+            ]
+            repaired.append(candidate_span)
+    return repaired
+
+
+def repair_city_before_postcode(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for match in CITY_BEFORE_POSTCODE_RE.finditer(text):
+        start, end = match.span(1)
+        value = text[start:end]
+        if any(ch.isdigit() for ch in value):
+            continue
+        prefix = text[max(0, start - 20) : start]
+        if CITY_COUNTY_PREFIX_RE.search(prefix):
+            continue
+        has_context = False
+        for other in repaired:
+            other_start = int(other["start"])
+            other_end = int(other["end"])
+            if other["label"] == "STREET_ADDRESS" and 0 <= start - other_end <= 4:
+                has_context = True
+                break
+            if other["label"] == "POSTCODE" and 0 <= other_start - end <= 6:
+                has_context = True
+                break
+        if not has_context:
+            cue_window = text[max(0, start - 40) : min(len(text), end + 24)]
+            has_context = bool(CITY_CUE_RE.search(cue_window) or ADDRESS_CUE_RE.search(cue_window))
+        if not has_context:
+            continue
+        candidate_span = {
+            "start": start,
+            "end": end,
+            "label": "CITY",
+            "score": 0.63,
+            "text": value,
+        }
+        if any(
+            other["label"] == "CITY"
+            and spans_overlap(candidate_span, other)
+            and (int(other["end"]) - int(other["start"])) >= (end - start)
+            for other in repaired
+        ):
+            continue
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(candidate_span, other)
+                and other["label"] in {"CITY", "FIRST_NAME", "LAST_NAME"}
+            )
+        ]
+        repaired.append(candidate_span)
+    return repaired
+
+
+def repair_city_before_county(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for regex in (CITY_TOWN_SUFFIX_RE, CITY_BEFORE_COUNTY_RE):
+        for match in regex.finditer(text):
+            start, end = match.span(1)
+            value = text[start:end]
+            if any(ch.isdigit() for ch in value):
+                continue
+            prefix = text[max(0, start - 20) : start]
+            if CITY_COUNTY_PREFIX_RE.search(prefix):
+                continue
+            cue_window = text[max(0, start - 40) : min(len(text), end + 24)]
+            if not ((CITY_CUE_RE.search(cue_window) or ADDRESS_CUE_RE.search(cue_window)) or re.search(r"^\s*,\s*(?:County|Contae|gContae|Co\.)\b", text[end:])):
+                continue
+            candidate_span = {
+                "start": start,
+                "end": end,
+                "label": "CITY",
+                "score": 0.64,
+                "text": value,
+            }
+            if any(
+                other["label"] == "CITY"
+                and spans_overlap(candidate_span, other)
+                and (int(other["end"]) - int(other["start"])) >= (end - start)
+                for other in repaired
+            ):
+                continue
+            repaired = [
+                other
+                for other in repaired
+                if not (
+                    spans_overlap(candidate_span, other)
+                    and other["label"] in {"CITY", "FIRST_NAME", "LAST_NAME"}
+                )
+            ]
+            repaired.append(candidate_span)
+    return repaired
+
+
+def repair_city_field_cues(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    seen: set[tuple[int, int]] = set()
+    for regex in (CITY_FIELD_VALUE_RE, INLINE_CITY_FIELD_VALUE_RE):
+        for match in regex.finditer(text):
+            start, end = match.span(1)
+            if (start, end) in seen:
+                continue
+            seen.add((start, end))
+            candidate_span = {
+                "start": start,
+                "end": end,
+                "label": "CITY",
+                "score": 0.65,
+                "text": text[start:end],
+            }
+            repaired = [
+                other
+                for other in repaired
+                if not (
+                    spans_overlap(candidate_span, other)
+                    and other["label"] in {"CITY", "COUNTY", "FIRST_NAME", "LAST_NAME"}
+                )
+            ]
+            repaired.append(candidate_span)
+    return repaired
+
+
+def repair_prefixed_city_spans(text: str, spans: list[dict]) -> list[dict]:
+    repaired: list[dict] = []
+    for span in spans:
+        if span["label"] != "CITY":
+            repaired.append(span)
+            continue
+        start = int(span["start"])
+        end = int(span["end"])
+        if start <= 0:
+            repaired.append(span)
+            continue
+        prefix_char = text[start - 1]
+        if prefix_char.lower() not in IRISH_CITY_PREFIX_CHARS:
+            repaired.append(span)
+            continue
+        if start - 1 > 0 and text[start - 2].isalpha():
+            repaired.append(span)
+            continue
+        if normalize_surface(span.get("text", "")) not in IRISH_CITY_SURFACES:
+            repaired.append(span)
+            continue
+        candidate_start = start - 1
+        candidate_text = text[candidate_start:end]
+        repaired.append(
+            {
+                **span,
+                "start": candidate_start,
+                "text": candidate_text,
+                "score": max(float(span.get("score", 0.0)), 0.66),
+            }
+        )
+    return repaired
+
+
+def prefer_long_city_spans(spans: list[dict]) -> list[dict]:
+    if not spans:
+        return spans
+    keep: list[dict] = []
+    for span in spans:
+        if span["label"] != "CITY":
+            keep.append(span)
+            continue
+        shadowed = False
+        for other in spans:
+            if other is span or other["label"] != "CITY":
+                continue
+            if int(other["start"]) <= int(span["start"]) and int(other["end"]) >= int(span["end"]):
+                if (int(other["start"]), int(other["end"])) != (int(span["start"]), int(span["end"])):
+                    if float(other.get("score", 0.0)) >= max(0.6, float(span.get("score", 0.0)) * 0.6):
+                        shadowed = True
+                        break
+        if not shadowed:
+            keep.append(span)
+    return keep
+
+
+def repair_county_field_cues(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    seen: set[tuple[int, int]] = set()
+    for regex in (COUNTY_FIELD_VALUE_RE, INLINE_COUNTY_FIELD_VALUE_RE):
+        for match in regex.finditer(text):
+            start, end = match.span(1)
+            if (start, end) in seen:
+                continue
+            seen.add((start, end))
+            candidate_span = {
+                "start": start,
+                "end": end,
+                "label": "COUNTY",
+                "score": 0.66,
+                "text": text[start:end],
+            }
+            repaired = [
+                other
+                for other in repaired
+                if not (
+                    spans_overlap(candidate_span, other)
+                    and other["label"] in {"COUNTY", "CITY", "FIRST_NAME", "LAST_NAME"}
+                )
+            ]
+            repaired.append(candidate_span)
+    return repaired
+
+
+def repair_county_spans(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    seen: set[tuple[int, int]] = set()
+    ordered_forms = sorted(IRISH_COUNTY_FORMS, key=len, reverse=True)
+    for form in ordered_forms:
+        for match in iter_bounded_form_matches(form, text):
+            start, end = match.span()
+            key = (start, end)
+            if key in seen:
+                continue
+            seen.add(key)
+            candidate_span = {
+                "start": start,
+                "end": end,
+                "label": "COUNTY",
+                "score": 0.74,
+                "text": text[start:end],
+            }
+            if not is_reasonable_span_text("COUNTY", text, start, end):
+                continue
+            overlapping_counties = [
+                other
+                for other in repaired
+                if spans_overlap(candidate_span, other) and other["label"] == "COUNTY"
+            ]
+            if overlapping_counties:
+                candidate_span["score"] = max(
+                    float(candidate_span["score"]),
+                    max(float(other.get("score", 0.0)) for other in overlapping_counties),
+                )
+            conflicting_labels = {"COUNTY", "CITY", "FIRST_NAME", "LAST_NAME"}
+            repaired = [
+                other
+                for other in repaired
+                if not (
+                    spans_overlap(candidate_span, other)
+                    and other["label"] in conflicting_labels
+                )
+            ]
+            repaired.append(candidate_span)
+    for match in COUNTY_VALUE_RE.finditer(text):
+        start, end = match.span(1)
+        key = (start, end)
+        if key in seen:
+            continue
+        context = text[max(0, start - 40) : min(len(text), end + 24)]
+        has_context = bool(ADDRESS_CUE_RE.search(context) or POSTCODE_VALUE_RE.search(context))
+        if not has_context:
+            for other in repaired:
+                other_start = int(other["start"])
+                other_end = int(other["end"])
+                if other["label"] in {"STREET_ADDRESS", "CITY", "POSTCODE"} and (
+                    abs(other_start - end) <= 24 or abs(start - other_end) <= 24
+                ):
+                    has_context = True
+                    break
+        if not has_context:
+            continue
+        seen.add(key)
+        candidate_span = {
+            "start": start,
+            "end": end,
+            "label": "COUNTY",
+            "score": 0.74,
+            "text": text[start:end],
+        }
+        if not is_reasonable_span_text("COUNTY", text, start, end):
+            continue
+        conflicting_labels = {"COUNTY", "CITY", "FIRST_NAME", "LAST_NAME"}
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(candidate_span, other)
+                and other["label"] in conflicting_labels
+            )
+        ]
+        repaired.append(candidate_span)
+    return repaired
+
+
+def repair_street_addresses(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    seen: set[tuple[int, int]] = set()
+    for match in STREET_ADDRESS_VALUE_RE.finditer(text):
+        start, end = match.span(1)
+        key = (start, end)
+        if key in seen:
+            continue
+        seen.add(key)
+        candidate_span = {
+            "start": start,
+            "end": end,
+            "label": "STREET_ADDRESS",
+            "score": 0.65,
+            "text": text[start:end],
+        }
+        if not is_reasonable_span_text("STREET_ADDRESS", text, start, end):
+            continue
+        context = text[max(0, start - 32) : min(len(text), end + 24)]
+        has_context = bool(ADDRESS_CUE_RE.search(context))
+        if not has_context:
+            for other in repaired:
+                other_start = int(other["start"])
+                other_end = int(other["end"])
+                if other["label"] in {"CITY", "COUNTY", "POSTCODE"} and 0 <= other_start - end <= 16:
+                    has_context = True
+                    break
+                if other["label"] in {"FIRST_NAME", "LAST_NAME"} and 0 <= start - other_end <= 24:
+                    has_context = True
+                    break
+        if not has_context:
+            continue
+        conflicting_labels = {"STREET_ADDRESS", "FIRST_NAME", "LAST_NAME"}
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(candidate_span, other)
+                and other["label"] in conflicting_labels
+            )
+        ]
+        repaired.append(candidate_span)
+    return repaired
+
+
+def repair_contextual_address_blocks(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for match in ADDRESS_BLOCK_VALUE_RE.finditer(text):
+        start, end = match.span(1)
+        value = text[start:end].strip()
+        if not value:
+            continue
+        candidate_span = {
+            "start": start,
+            "end": end,
+            "label": "STREET_ADDRESS",
+            "score": 0.68,
+            "text": text[start:end],
+        }
+        tokens = [token for token in re.split(r"\s+", value) if token]
+        if len(tokens) < 2:
+            continue
+        has_digit = any(ch.isdigit() for ch in value)
+        has_prefix = bool(ADDRESS_UNIT_PREFIX_RE.match(value) or HOUSE_NAME_PREFIX_RE.match(value))
+        has_street_suffix = bool(STREET_SUFFIX_RE.search(value))
+        cue_window = text[max(0, start - 40) : start]
+        has_address_line_cue = bool(ADDRESS_LINE_CUE_RE.search(cue_window))
+        if not (has_digit or has_prefix):
+            continue
+        if not has_street_suffix:
+            tail_window = text[end : min(len(text), end + 48)]
+            has_following_address_context = bool(
+                re.match(
+                    r"^\s*,\s*((?:\d{1,4}\s+)?(?:[A-ZÁÉÍÓÚa-záéíóú][\w'’.-]*\s+){0,5}(?:street|road|avenue|lane|park|view|square|terrace|drive|close|way|place|crescent|grove|green|court|manor|mews|gardens?|heights|quay|bóthar|bothar|sráid|sraid|lána|lana))",
+                    tail_window,
+                    flags=re.IGNORECASE,
+                )
+                or re.search(r"(?:County|Contae|gContae|Co\.|(?:[A-Z]\d{2}|D6W))", tail_window)
+            )
+            building_tail_match = ADDRESS_BUILDING_TAIL_RE.match(tail_window)
+            has_following_building_context = False
+            if building_tail_match:
+                remaining_tail = tail_window[int(building_tail_match.end(1)) :]
+                has_following_building_context = bool(
+                    re.match(
+                        r"^\s*(?:$|,\s*(?:(?:\d{1,4}\s+)?(?:[A-ZÁÉÍÓÚa-záéíóú][\w'’.-]*\s+){0,5}(?:street|road|avenue|lane|park|view|square|terrace|drive|close|way|place|crescent|grove|green|court|manor|mews|gardens?|heights|quay|bóthar|bothar|sráid|sraid|lána|lana)|County|Contae|gContae|Co\.|(?:[A-Z]\d{2}|D6W)|[A-ZÁÉÍÓÚ]))",
+                        remaining_tail,
+                        flags=re.IGNORECASE,
+                    )
+                )
+            looks_like_suffixless_address = has_digit and len(tokens) >= 3
+            if not ((has_prefix and (has_address_line_cue or has_following_building_context)) or ((has_prefix or looks_like_suffixless_address) and has_following_address_context)):
+                continue
+        if any(
+            other["label"] == "STREET_ADDRESS"
+            and int(other["start"]) <= start
+            and int(other["end"]) >= end
+            and (int(other["start"]), int(other["end"])) != (start, end)
+            for other in repaired
+        ):
+            continue
+        conflicting_labels = {"STREET_ADDRESS", "FIRST_NAME", "LAST_NAME"}
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(candidate_span, other)
+                and other["label"] in conflicting_labels
+            )
+        ]
+        repaired.append(candidate_span)
+    return repaired
+
+
+def extend_prefixed_street_address_spans(text: str, spans: list[dict]) -> list[dict]:
+    repaired: list[dict] = []
+    tail_re = re.compile(
+        r"^\s*,\s*((?:\d{1,4}\s+)?(?:[A-ZÁÉÍÓÚa-záéíóú][\w'’.-]*\s+){0,5}(?:street|road|avenue|lane|park|view|square|terrace|drive|close|way|place|crescent|grove|green|court|manor|mews|gardens?|heights|quay|bóthar|bothar|sráid|sraid|lána|lana)(?:\s+[A-ZÁÉÍÓÚa-záéíóú][\w'’.-]*){0,2})",
+        flags=re.IGNORECASE,
+    )
+    building_follow_context_re = re.compile(
+        r"^\s*(?:$|[.;]|,\s*(?:(?:\d{1,4}\s+)?(?:[A-ZÁÉÍÓÚa-záéíóú][\w'’.-]*\s+){0,5}(?:street|road|avenue|lane|park|view|square|terrace|drive|close|way|place|crescent|grove|green|court|manor|mews|gardens?|heights|quay|bóthar|bothar|sráid|sraid|lána|lana)|County|Contae|gContae|Co\.|(?:[A-Z]\d{2}|D6W)|[A-ZÁÉÍÓÚ]))",
+        flags=re.IGNORECASE,
+    )
+    for span in spans:
+        if span["label"] != "STREET_ADDRESS":
+            repaired.append(span)
+            continue
+        value = span.get("text", "").strip()
+        if not value or not (ADDRESS_UNIT_PREFIX_RE.match(value) or HOUSE_NAME_PREFIX_RE.match(value)):
+            repaired.append(span)
+            continue
+        tail_match = tail_re.match(text[int(span["end"]) :])
+        if tail_match:
+            extended_end = int(span["end"]) + int(tail_match.end(1))
+            repaired.append(
+                {
+                    **span,
+                    "end": extended_end,
+                    "text": text[int(span["start"]) : extended_end],
+                    "score": max(float(span.get("score", 0.0)), 0.67),
+                }
+            )
+            continue
+        building_tail_match = ADDRESS_BUILDING_TAIL_RE.match(text[int(span["end"]) :])
+        if not building_tail_match:
+            repaired.append(span)
+            continue
+        remaining_tail = text[int(span["end"]) + int(building_tail_match.end(1)) :]
+        extended_end = int(span["end"]) + int(building_tail_match.end(1))
+        repaired.append(
+            {
+                **span,
+                "end": extended_end,
+                "text": text[int(span["start"]) : extended_end],
+                "score": max(float(span.get("score", 0.0)), 0.67),
+            }
+        )
+    return repaired
+
+
+def merge_adjacent_street_address_spans(text: str, spans: list[dict]) -> list[dict]:
+    if not spans:
+        return spans
+    ordered = sorted(spans, key=lambda item: (int(item["start"]), int(item["end"]), item["label"]))
+    merged: list[dict] = []
+    index = 0
+    while index < len(ordered):
+        span = ordered[index]
+        if span["label"] != "STREET_ADDRESS":
+            merged.append(span)
+            index += 1
+            continue
+        current = dict(span)
+        lookahead = index + 1
+        while lookahead < len(ordered):
+            other = ordered[lookahead]
+            if other["label"] != "STREET_ADDRESS":
+                break
+            gap = text[int(current["end"]) : int(other["start"])]
+            if not re.fullmatch(r"\s*,\s*", gap):
+                break
+            candidate_end = int(other["end"])
+            merged_value = text[int(current["start"]) : candidate_end]
+            if not (
+                any(ch.isdigit() for ch in merged_value)
+                and (
+                    ADDRESS_UNIT_PREFIX_RE.match(merged_value)
+                    or STREET_SUFFIX_RE.search(merged_value)
+                    or BUILDING_SUFFIX_RE.search(merged_value)
+                )
+            ):
+                break
+            current["end"] = candidate_end
+            current["text"] = text[int(current["start"]) : candidate_end]
+            current["score"] = max(float(current.get("score", 0.0)), float(other.get("score", 0.0)))
+            lookahead += 1
+        merged.append(current)
+        index = lookahead
+    return merged
+
+
+def repair_contextual_address_place_blocks(text: str, spans: list[dict]) -> list[dict]:
+    repaired = list(spans)
+    for match in ADDRESS_PLACE_VALUE_RE.finditer(text):
+        start, end = match.span(1)
+        candidate_span = {
+            "start": start,
+            "end": end,
+            "label": "STREET_ADDRESS",
+            "score": 0.69,
+            "text": text[start:end],
+        }
+        repaired = [
+            other
+            for other in repaired
+            if not (
+                spans_overlap(candidate_span, other)
+                and other["label"] in {"STREET_ADDRESS", "FIRST_NAME", "LAST_NAME", "CITY"}
+            )
+        ]
+        repaired.append(candidate_span)
+    return repaired
+
+
+def prefer_long_street_address_spans(spans: list[dict]) -> list[dict]:
+    if not spans:
+        return spans
+    keep: list[dict] = []
+    for span in spans:
+        if span["label"] != "STREET_ADDRESS":
+            keep.append(span)
+            continue
+        shadowed = False
+        for other in spans:
+            if other is span or other["label"] != "STREET_ADDRESS":
+                continue
+            if int(other["start"]) <= int(span["start"]) and int(other["end"]) >= int(span["end"]):
+                if (int(other["start"]), int(other["end"])) != (int(span["start"]), int(span["end"])):
+                    shadowed = True
+                    break
+        if not shadowed:
+            keep.append(span)
+    return keep
+
+
+def drop_contextual_fragment_spans(spans: list[dict]) -> list[dict]:
+    if not spans:
+        return spans
+    suppressors = {"COUNTY", "CITY", "POSTCODE", "STREET_ADDRESS", "DATE_OF_BIRTH"}
+    keep: list[dict] = []
+    for span in spans:
+        if span["label"] in {"FIRST_NAME", "LAST_NAME"}:
+            if any(
+                other is not span
+                and other["label"] in suppressors
+                and spans_overlap(span, other)
+                and (int(other["end"]) - int(other["start"])) >= (int(span["end"]) - int(span["start"]))
+                for other in spans
+            ):
+                continue
+        if span["label"] == "CITY":
+            if any(
+                other is not span
+                and other["label"] == "COUNTY"
+                and spans_overlap(span, other)
+                and (int(other["end"]) - int(other["start"])) >= (int(span["end"]) - int(span["start"]))
+                for other in spans
+            ):
+                continue
+        keep.append(span)
+    return keep
+
+
+def drop_public_contact_detail_spans(text: str, spans: list[dict]) -> list[dict]:
+    if not PUBLIC_CONTACT_DETAILS_RE.search(text):
+        return spans
+    keep: list[dict] = []
+    for span in spans:
+        if span["label"] not in {"STREET_ADDRESS", "CITY", "COUNTY"}:
+            keep.append(span)
+            continue
+        keep.append(span)
+    return [
+        span for span in keep
+        if not (span["label"] in {"STREET_ADDRESS", "CITY", "COUNTY"} and PUBLIC_CONTACT_DETAILS_RE.search(text))
+    ]
+
+
+def drop_org_like_name_spans(text: str, spans: list[dict]) -> list[dict]:
+    keep: list[dict] = []
+    for span in spans:
+        if span["label"] not in {"FIRST_NAME", "LAST_NAME"}:
+            keep.append(span)
+            continue
+        tokens = [normalize_surface(token) for token in re.split(r"\s+", span.get("text", "").strip()) if token]
+        if tokens and tokens[-1] in ORG_NAME_TRAILING_SURFACES:
+            continue
+        prefix = text[max(0, int(span["start"]) - 32) : int(span["start"])]
+        if ORG_NAME_PREFIX_RE.search(prefix):
+            continue
+        keep.append(span)
+    return keep
+
+
+def drop_city_org_prefix_spans(text: str, spans: list[dict]) -> list[dict]:
+    keep: list[dict] = []
+    for span in spans:
+        if span["label"] != "CITY":
+            keep.append(span)
+            continue
+        tail = text[int(span["end"]) : min(len(text), int(span["end"]) + 24)]
+        if ORG_CITY_TAIL_RE.match(tail):
+            continue
+        keep.append(span)
+    return keep
+
+
+def canonicalize_location_spans(text: str, spans: list[dict]) -> list[dict]:
+    repaired: list[dict] = []
+    for span in spans:
+        if span["label"] not in {"CITY", "COUNTY"}:
+            repaired.append(span)
+            continue
+        start = int(span["start"])
+        end = int(span["end"])
+        while end > start and text[end - 1] in ".,;:":
+            end -= 1
+        repaired.append(
+            {
+                **span,
+                "end": end,
+                "text": text[start:end],
+            }
+        )
+    return repaired
+
+
+def canonicalize_street_address_spans(text: str, spans: list[dict]) -> list[dict]:
+    repaired: list[dict] = []
+    for span in spans:
+        if span["label"] != "STREET_ADDRESS":
+            repaired.append(span)
+            continue
+        start = int(span["start"])
+        end = int(span["end"])
+        while end > start and text[end - 1] in ".,;:":
+            end -= 1
+        repaired.append(
+            {
+                **span,
+                "end": end,
+                "text": text[start:end],
+            }
+        )
+    return repaired
+
+
+def canonicalize_email_spans(text: str, spans: list[dict]) -> list[dict]:
+    repaired: list[dict] = []
+    for span in spans:
+        if span["label"] != "EMAIL":
+            repaired.append(span)
+            continue
+        segment = text[int(span["start"]) : int(span["end"])]
+        match = EMAIL_EXTRACT_RE.search(segment)
+        if not match:
+            repaired.append(span)
+            continue
+        start = int(span["start"]) + int(match.start(1))
+        end = int(span["start"]) + int(match.end(1))
+        repaired.append(
+            {
+                **span,
+                "start": start,
+                "end": end,
+                "text": text[start:end],
+            }
+        )
+    return repaired
+
+
+def drop_stacked_first_names(spans: list[dict]) -> list[dict]:
+    if not spans:
+        return spans
+    first_names = [span for span in spans if span["label"] == "FIRST_NAME"]
+    last_names = [span for span in spans if span["label"] == "LAST_NAME"]
+    if not first_names or not last_names:
+        return spans
+    keep: list[dict] = []
+    for span in spans:
+        if span["label"] != "FIRST_NAME":
+            keep.append(span)
+            continue
+        shadowed = False
+        for other in first_names:
+            if other is span:
+                continue
+            if int(other["start"]) <= int(span["start"]):
+                continue
+            if int(other["start"]) - int(span["end"]) > 2:
+                continue
+            if not any(
+                int(last["start"]) >= int(other["end"]) and int(last["start"]) - int(other["end"]) <= 2
+                for last in last_names
+            ):
+                continue
+            shadowed = True
+            break
+        if not shadowed:
+            keep.append(span)
+    return keep
+
+
+def decode_span_matrix(
+    text: str,
+    offsets: list[tuple[int, int]],
+    span_scores: np.ndarray,
+    config,
+    min_score: float,
+) -> list[dict]:
+    label_names = label_names_from_config(config)
+    thresholds = label_thresholds_from_config(config, min_score)
+    max_span_tokens = label_max_span_tokens_from_config(config)
+    min_nonspace_chars = label_min_nonspace_chars_from_config(config)
+
+    if span_scores.ndim != 3:
+        raise ValueError(f"Expected [num_labels, seq_len, seq_len] span scores, got shape {span_scores.shape}")
+
+    num_labels, seq_len, _ = span_scores.shape
+    valid = np.array([valid_offset(offset) for offset in offsets[:seq_len]], dtype=bool)
+    start_chars = np.array([int(offset[0]) if valid[index] else -1 for index, offset in enumerate(offsets[:seq_len])], dtype=np.int32)
+    end_chars = np.array([int(offset[1]) if valid[index] else -1 for index, offset in enumerate(offsets[:seq_len])], dtype=np.int32)
+    nonspace_prefix = [0]
+    for ch in text:
+        nonspace_prefix.append(nonspace_prefix[-1] + (0 if ch.isspace() else 1))
+    spans: list[dict] = []
+    for label_index in range(min(num_labels, len(label_names))):
+        label = label_names[label_index]
+        threshold = thresholds.get(label, min_score)
+        max_width = max(1, int(max_span_tokens.get(label, 8)))
+        min_chars = max(1, int(min_nonspace_chars.get(label, 1)))
+        label_scores = span_scores[label_index, :seq_len, :seq_len]
+        start_indices, end_indices = np.where(label_scores >= threshold)
+        if start_indices.size == 0:
+            continue
+        width_mask = (end_indices >= start_indices) & ((end_indices - start_indices) < max_width)
+        if not np.any(width_mask):
+            continue
+        start_indices = start_indices[width_mask]
+        end_indices = end_indices[width_mask]
+        valid_mask = valid[start_indices] & valid[end_indices]
+        if not np.any(valid_mask):
+            continue
+        start_indices = start_indices[valid_mask]
+        end_indices = end_indices[valid_mask]
+        for start_idx, end_idx in zip(start_indices.tolist(), end_indices.tolist()):
+            start_char = int(start_chars[start_idx])
+            end_char = int(end_chars[end_idx])
+            if end_char <= start_char:
+                continue
+            if (nonspace_prefix[end_char] - nonspace_prefix[start_char]) < min_chars:
+                continue
+            if not is_reasonable_span_text(label, text, start_char, end_char):
+                continue
+            spans.append(
+                {
+                    "start": start_char,
+                    "end": end_char,
+                    "label": label,
+                    "score": float(label_scores[start_idx, end_idx]),
+                    "text": text[start_char:end_char],
+                }
+            )
+    spans = prefer_long_name_spans(spans, thresholds)
+    spans = prefer_long_structured_spans(spans, thresholds)
+    spans = repair_first_name_from_last_name(text, spans)
+    text_lower = text.lower()
+    has_digit = any(ch.isdigit() for ch in text)
+    has_email_hint = "@" in text
+    has_address_hint = bool(
+        ADDRESS_CUE_RE.search(text)
+        or ADDRESS_LINE_CUE_RE.search(text)
+        or STREET_SUFFIX_RE.search(text)
+        or HOUSE_NAME_PREFIX_RE.search(text)
+        or ADDRESS_UNIT_PREFIX_RE.search(text)
+    )
+    has_city_hint = bool(
+        has_address_hint
+        or POSTCODE_VALUE_RE.search(text)
+        or "city:" in text_lower
+        or "city " in text_lower
+        or "town:" in text_lower
+        or "town " in text_lower
+        or "city/town" in text_lower
+        or "cathair" in text_lower
+        or "baile" in text_lower
+        or "county" in text_lower
+        or "contae" in text_lower
+        or "co." in text_lower
+    )
+    has_name_spans = any(span["label"] in {"FIRST_NAME", "LAST_NAME"} for span in spans)
+    if has_email_hint:
+        spans = repair_emails(text, spans)
+    if has_digit:
+        spans = repair_phone_numbers(text, spans)
+        spans = repair_ppsn_variants(text, spans)
+        spans = repair_postcodes(text, spans)
+    if has_address_hint:
+        spans = repair_street_addresses(text, spans)
+    if NAME_SELF_CUE_RE.search(text):
+        spans = repair_contextual_name_cues(text, spans)
+    if NAME_ROLE_CUE_RE.search(text):
+        spans = repair_role_name_cues(text, spans)
+    if SURNAME_CUE_RE.search(text):
+        spans = repair_surname_field_cues(text, spans)
+    if NAME_BEFORE_STRUCTURED_CUE_RE.search(text):
+        spans = repair_name_before_structured_cues(text, spans)
+    if has_name_spans and NAME_PARTICLE_SURNAME_RE.search(text):
+        spans = repair_name_particle_surnames(text, spans)
+    if has_address_hint:
+        spans = repair_contextual_address_blocks(text, spans)
+        spans = extend_prefixed_street_address_spans(text, spans)
+        spans = repair_contextual_address_place_blocks(text, spans)
+        spans = merge_adjacent_street_address_spans(text, spans)
+        spans = prefer_long_street_address_spans(spans)
+    if has_city_hint:
+        spans = repair_county_spans(text, spans)
+        spans = repair_city_spans(text, spans)
+        spans = repair_city_before_postcode(text, spans)
+        spans = repair_city_before_county(text, spans)
+        spans = repair_city_field_cues(text, spans)
+        spans = repair_prefixed_city_spans(text, spans)
+        spans = prefer_long_city_spans(spans)
+        spans = repair_county_field_cues(text, spans)
+    if has_digit and DOB_CONTEXT_RE.search(text):
+        spans = repair_contextual_date_of_birth(text, spans)
+    if has_digit and AGE_CONTEXT_RE.search(text):
+        spans = repair_contextual_ages(text, spans)
+    if has_digit and PASSPORT_CUE_RE.search(text):
+        spans = repair_contextual_passport_numbers(text, spans)
+    if has_digit and ("iban" in text_lower or "account" in text_lower or "bank" in text_lower or "cuntas" in text_lower):
+        spans = repair_contextual_account_numbers(text, spans)
+    if "public contact details" in text_lower:
+        spans = drop_public_contact_detail_spans(text, spans)
+    if any(span["label"] in {"FIRST_NAME", "LAST_NAME"} for span in spans):
+        spans = drop_org_like_name_spans(text, spans)
+        spans = drop_stacked_first_names(spans)
+    if any(span["label"] == "CITY" for span in spans):
+        spans = drop_city_org_prefix_spans(text, spans)
+    if any(span["label"] in {"FIRST_NAME", "LAST_NAME", "CITY"} for span in spans):
+        spans = drop_contextual_fragment_spans(spans)
+    if any(span["label"] in {"CITY", "COUNTY"} for span in spans):
+        spans = canonicalize_location_spans(text, spans)
+    if any(span["label"] == "STREET_ADDRESS" for span in spans):
+        spans = canonicalize_street_address_spans(text, spans)
+    if any(span["label"] == "EMAIL" for span in spans):
+        spans = canonicalize_email_spans(text, spans)
+    return dedupe_spans(spans)
+
+
+def prefer_long_name_spans(spans: list[dict], thresholds: dict[str, float]) -> list[dict]:
+    if not spans:
+        return spans
+    preferred: list[dict] = []
+    consumed: set[int] = set()
+    for index, span in enumerate(spans):
+        if index in consumed:
+            continue
+        label = span["label"]
+        if label not in {"FIRST_NAME", "LAST_NAME"}:
+            preferred.append(span)
+            continue
+        same_start = [
+            (other_index, other)
+            for other_index, other in enumerate(spans)
+            if other_index not in consumed and other["label"] == label and other["start"] == span["start"]
+        ]
+        if len(same_start) == 1:
+            preferred.append(span)
+            continue
+        for other_index, _ in same_start:
+            consumed.add(other_index)
+        best_by_score = max(same_start, key=lambda item: float(item[1].get("score", 0.0)))[1]
+        longest = max(same_start, key=lambda item: (item[1]["end"] - item[1]["start"], float(item[1].get("score", 0.0))))[1]
+        threshold = float(thresholds.get(label, 0.5))
+        if float(longest.get("score", 0.0)) >= max(threshold + 0.15, float(best_by_score.get("score", 0.0)) * 0.7):
+            preferred.append(longest)
+        else:
+            preferred.append(best_by_score)
+    return prefer_same_end_extensions(preferred, thresholds)
+
+
+def prefer_same_end_extensions(spans: list[dict], thresholds: dict[str, float]) -> list[dict]:
+    if not spans:
+        return spans
+    preferred: list[dict] = []
+    consumed: set[int] = set()
+    for index, span in enumerate(spans):
+        if index in consumed:
+            continue
+        label = span["label"]
+        if label not in {"FIRST_NAME", "LAST_NAME", "EMAIL"}:
+            preferred.append(span)
+            continue
+        same_end = [
+            (other_index, other)
+            for other_index, other in enumerate(spans)
+            if other_index not in consumed and other["label"] == label and other["end"] == span["end"]
+        ]
+        if len(same_end) == 1:
+            preferred.append(span)
+            continue
+        for other_index, _ in same_end:
+            consumed.add(other_index)
+        best_by_score = max(same_end, key=lambda item: float(item[1].get("score", 0.0)))[1]
+        longest = max(same_end, key=lambda item: (item[1]["end"] - item[1]["start"], float(item[1].get("score", 0.0))))[1]
+        longest_score = float(longest.get("score", 0.0))
+        best_score = float(best_by_score.get("score", 0.0))
+        if label == "EMAIL":
+            if "@" in longest.get("text", "") or longest["end"] - longest["start"] > best_by_score["end"] - best_by_score["start"]:
+                if longest_score >= best_score - 0.02:
+                    preferred.append(longest)
+                    continue
+        else:
+            longest_text = longest.get("text", "")
+            if " " not in longest_text.strip() and longest_score >= max(float(thresholds.get(label, 0.5)) * 0.8, best_score * 0.55):
+                preferred.append(longest)
+                continue
+        preferred.append(best_by_score)
+    return preferred
+
+
+def prefer_long_structured_spans(spans: list[dict], thresholds: dict[str, float]) -> list[dict]:
+    if not spans:
+        return spans
+    preferred: list[dict] = []
+    consumed: set[int] = set()
+    target_labels = {"STREET_ADDRESS", "DATE_OF_BIRTH"}
+    for index, span in enumerate(spans):
+        if index in consumed:
+            continue
+        label = span["label"]
+        if label not in target_labels:
+            preferred.append(span)
+            continue
+        overlapping = [
+            (other_index, other)
+            for other_index, other in enumerate(spans)
+            if other_index not in consumed and other["label"] == label and spans_overlap(span, other)
+        ]
+        if len(overlapping) == 1:
+            preferred.append(span)
+            continue
+        for other_index, _ in overlapping:
+            consumed.add(other_index)
+        best_by_score = max(overlapping, key=lambda item: float(item[1].get("score", 0.0)))[1]
+        longest = max(
+            overlapping,
+            key=lambda item: (item[1]["end"] - item[1]["start"], float(item[1].get("score", 0.0))),
+        )[1]
+        longest_score = float(longest.get("score", 0.0))
+        best_score = float(best_by_score.get("score", 0.0))
+        threshold = float(thresholds.get(label, 0.5))
+        if longest_score >= max(threshold, best_score * 0.75):
+            preferred.append(longest)
+        else:
+            preferred.append(best_by_score)
+    return preferred
+
+
+def sigmoid_np(values: np.ndarray) -> np.ndarray:
+    clipped = np.clip(values, -60.0, 60.0)
+    return 1.0 / (1.0 + np.exp(-clipped))
+
+
+def run_onnx_span(session, encoded: dict[str, Any]) -> np.ndarray:
+    feed = {}
+    input_names = {item.name for item in session.get_inputs()}
+    for key, value in encoded.items():
+        if key == "offset_mapping":
+            continue
+        if key in input_names:
+            feed[key] = value
+    outputs = session.run(None, feed)
+    if not outputs:
+        raise ValueError("ONNX session returned no outputs")
+    return outputs[0]

config.json

@@ -0,0 +1,318 @@
+{
+  "activation": "gelu",
+  "architectures": [
+    "IrishCoreGlobalPointerModel"
+  ],
+  "attention_dropout": 0.1,
+  "dim": 768,
+  "dropout": 0.1,
+  "dtype": "float32",
+  "global_pointer_head_size": 64,
+  "global_pointer_min_negatives": 256,
+  "global_pointer_negative_ratio": 16,
+  "global_pointer_use_rope": true,
+  "hidden_dim": 3072,
+  "id2label": {
+    "0": "O",
+    "1": "B-account_number",
+    "2": "B-age",
+    "3": "B-api_key",
+    "4": "B-bank_routing_number",
+    "5": "B-biometric_identifier",
+    "6": "B-blood_type",
+    "7": "B-certificate_license_number",
+    "8": "B-city",
+    "9": "B-company_name",
+    "10": "B-coordinate",
+    "11": "B-country",
+    "12": "B-county",
+    "13": "B-credit_debit_card",
+    "14": "B-customer_id",
+    "15": "B-cvv",
+    "16": "B-date",
+    "17": "B-date_of_birth",
+    "18": "B-date_time",
+    "19": "B-device_identifier",
+    "20": "B-education_level",
+    "21": "B-email",
+    "22": "B-employee_id",
+    "23": "B-employment_status",
+    "24": "B-fax_number",
+    "25": "B-first_name",
+    "26": "B-gender",
+    "27": "B-health_plan_beneficiary_number",
+    "28": "B-http_cookie",
+    "29": "B-ipv4",
+    "30": "B-ipv6",
+    "31": "B-language",
+    "32": "B-last_name",
+    "33": "B-license_plate",
+    "34": "B-mac_address",
+    "35": "B-medical_record_number",
+    "36": "B-occupation",
+    "37": "B-password",
+    "38": "B-phone_number",
+    "39": "B-pin",
+    "40": "B-political_view",
+    "41": "B-postcode",
+    "42": "B-race_ethnicity",
+    "43": "B-religious_belief",
+    "44": "B-sexuality",
+    "45": "B-ssn",
+    "46": "B-state",
+    "47": "B-street_address",
+    "48": "B-swift_bic",
+    "49": "B-tax_id",
+    "50": "B-time",
+    "51": "B-unique_id",
+    "52": "B-url",
+    "53": "B-user_name",
+    "54": "B-vehicle_identifier",
+    "55": "I-account_number",
+    "56": "I-api_key",
+    "57": "I-biometric_identifier",
+    "58": "I-blood_type",
+    "59": "I-certificate_license_number",
+    "60": "I-city",
+    "61": "I-company_name",
+    "62": "I-coordinate",
+    "63": "I-country",
+    "64": "I-county",
+    "65": "I-credit_debit_card",
+    "66": "I-customer_id",
+    "67": "I-date",
+    "68": "I-date_of_birth",
+    "69": "I-date_time",
+    "70": "I-device_identifier",
+    "71": "I-education_level",
+    "72": "I-email",
+    "73": "I-employee_id",
+    "74": "I-employment_status",
+    "75": "I-fax_number",
+    "76": "I-first_name",
+    "77": "I-gender",
+    "78": "I-health_plan_beneficiary_number",
+    "79": "I-http_cookie",
+    "80": "I-ipv4",
+    "81": "I-ipv6",
+    "82": "I-language",
+    "83": "I-last_name",
+    "84": "I-license_plate",
+    "85": "I-mac_address",
+    "86": "I-medical_record_number",
+    "87": "I-occupation",
+    "88": "I-password",
+    "89": "I-phone_number",
+    "90": "I-pin",
+    "91": "I-political_view",
+    "92": "I-postcode",
+    "93": "I-race_ethnicity",
+    "94": "I-religious_belief",
+    "95": "I-sexuality",
+    "96": "I-ssn",
+    "97": "I-state",
+    "98": "I-street_address",
+    "99": "I-swift_bic",
+    "100": "I-tax_id",
+    "101": "I-time",
+    "102": "I-unique_id",
+    "103": "I-url",
+    "104": "I-user_name",
+    "105": "I-vehicle_identifier"
+  },
+  "initializer_range": 0.02,
+  "label2id": {
+    "B-account_number": 1,
+    "B-age": 2,
+    "B-api_key": 3,
+    "B-bank_routing_number": 4,
+    "B-biometric_identifier": 5,
+    "B-blood_type": 6,
+    "B-certificate_license_number": 7,
+    "B-city": 8,
+    "B-company_name": 9,
+    "B-coordinate": 10,
+    "B-country": 11,
+    "B-county": 12,
+    "B-credit_debit_card": 13,
+    "B-customer_id": 14,
+    "B-cvv": 15,
+    "B-date": 16,
+    "B-date_of_birth": 17,
+    "B-date_time": 18,
+    "B-device_identifier": 19,
+    "B-education_level": 20,
+    "B-email": 21,
+    "B-employee_id": 22,
+    "B-employment_status": 23,
+    "B-fax_number": 24,
+    "B-first_name": 25,
+    "B-gender": 26,
+    "B-health_plan_beneficiary_number": 27,
+    "B-http_cookie": 28,
+    "B-ipv4": 29,
+    "B-ipv6": 30,
+    "B-language": 31,
+    "B-last_name": 32,
+    "B-license_plate": 33,
+    "B-mac_address": 34,
+    "B-medical_record_number": 35,
+    "B-occupation": 36,
+    "B-password": 37,
+    "B-phone_number": 38,
+    "B-pin": 39,
+    "B-political_view": 40,
+    "B-postcode": 41,
+    "B-race_ethnicity": 42,
+    "B-religious_belief": 43,
+    "B-sexuality": 44,
+    "B-ssn": 45,
+    "B-state": 46,
+    "B-street_address": 47,
+    "B-swift_bic": 48,
+    "B-tax_id": 49,
+    "B-time": 50,
+    "B-unique_id": 51,
+    "B-url": 52,
+    "B-user_name": 53,
+    "B-vehicle_identifier": 54,
+    "I-account_number": 55,
+    "I-api_key": 56,
+    "I-biometric_identifier": 57,
+    "I-blood_type": 58,
+    "I-certificate_license_number": 59,
+    "I-city": 60,
+    "I-company_name": 61,
+    "I-coordinate": 62,
+    "I-country": 63,
+    "I-county": 64,
+    "I-credit_debit_card": 65,
+    "I-customer_id": 66,
+    "I-date": 67,
+    "I-date_of_birth": 68,
+    "I-date_time": 69,
+    "I-device_identifier": 70,
+    "I-education_level": 71,
+    "I-email": 72,
+    "I-employee_id": 73,
+    "I-employment_status": 74,
+    "I-fax_number": 75,
+    "I-first_name": 76,
+    "I-gender": 77,
+    "I-health_plan_beneficiary_number": 78,
+    "I-http_cookie": 79,
+    "I-ipv4": 80,
+    "I-ipv6": 81,
+    "I-language": 82,
+    "I-last_name": 83,
+    "I-license_plate": 84,
+    "I-mac_address": 85,
+    "I-medical_record_number": 86,
+    "I-occupation": 87,
+    "I-password": 88,
+    "I-phone_number": 89,
+    "I-pin": 90,
+    "I-political_view": 91,
+    "I-postcode": 92,
+    "I-race_ethnicity": 93,
+    "I-religious_belief": 94,
+    "I-sexuality": 95,
+    "I-ssn": 96,
+    "I-state": 97,
+    "I-street_address": 98,
+    "I-swift_bic": 99,
+    "I-tax_id": 100,
+    "I-time": 101,
+    "I-unique_id": 102,
+    "I-url": 103,
+    "I-user_name": 104,
+    "I-vehicle_identifier": 105,
+    "O": 0
+  },
+  "max_position_embeddings": 512,
+  "model_type": "distilbert",
+  "n_heads": 12,
+  "n_layers": 6,
+  "num_span_labels": 16,
+  "output_past": true,
+  "pad_token_id": 0,
+  "qa_dropout": 0.1,
+  "seq_classif_dropout": 0.2,
+  "sinusoidal_pos_embds": false,
+  "span_label_max_span_tokens": {
+    "ACCOUNT_NUMBER": 19,
+    "AGE": 8,
+    "BANK_ROUTING_NUMBER": 6,
+    "CITY": 8,
+    "COUNTY": 8,
+    "CREDIT_DEBIT_CARD": 12,
+    "DATE_OF_BIRTH": 8,
+    "EMAIL": 16,
+    "FIRST_NAME": 6,
+    "LAST_NAME": 8,
+    "PASSPORT_NUMBER": 8,
+    "PHONE_NUMBER": 10,
+    "POSTCODE": 8,
+    "PPSN": 9,
+    "STREET_ADDRESS": 10,
+    "SWIFT_BIC": 8
+  },
+  "span_label_min_nonspace_chars": {
+    "ACCOUNT_NUMBER": 6,
+    "AGE": 1,
+    "BANK_ROUTING_NUMBER": 6,
+    "CITY": 1,
+    "COUNTY": 1,
+    "CREDIT_DEBIT_CARD": 12,
+    "DATE_OF_BIRTH": 1,
+    "EMAIL": 6,
+    "FIRST_NAME": 2,
+    "LAST_NAME": 2,
+    "PASSPORT_NUMBER": 7,
+    "PHONE_NUMBER": 7,
+    "POSTCODE": 6,
+    "PPSN": 8,
+    "STREET_ADDRESS": 1,
+    "SWIFT_BIC": 8
+  },
+  "span_label_names": [
+    "ACCOUNT_NUMBER",
+    "AGE",
+    "BANK_ROUTING_NUMBER",
+    "CITY",
+    "COUNTY",
+    "CREDIT_DEBIT_CARD",
+    "DATE_OF_BIRTH",
+    "EMAIL",
+    "FIRST_NAME",
+    "LAST_NAME",
+    "PASSPORT_NUMBER",
+    "PHONE_NUMBER",
+    "POSTCODE",
+    "PPSN",
+    "STREET_ADDRESS",
+    "SWIFT_BIC"
+  ],
+  "span_label_thresholds": {
+    "ACCOUNT_NUMBER": 0.5,
+    "AGE": 0.5,
+    "BANK_ROUTING_NUMBER": 0.5,
+    "CITY": 0.5,
+    "COUNTY": 0.5,
+    "CREDIT_DEBIT_CARD": 0.5,
+    "DATE_OF_BIRTH": 0.5,
+    "EMAIL": 0.5,
+    "FIRST_NAME": 0.5,
+    "LAST_NAME": 0.5,
+    "PASSPORT_NUMBER": 0.5,
+    "PHONE_NUMBER": 0.5,
+    "POSTCODE": 0.5,
+    "PPSN": 0.5,
+    "STREET_ADDRESS": 0.5,
+    "SWIFT_BIC": 0.5
+  },
+  "span_positive_weight": 8.0,
+  "tie_weights_": true,
+  "transformers_version": "4.57.6",
+  "vocab_size": 119547
+}

eval/benchmark_summary.json

@@ -0,0 +1,264 @@
+{
+  "release": "IrishCore-GlobalPointer-ContextPII-135M-v1-rc20",
+  "repo_id": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc20",
+  "architecture": {
+    "family": "DistilBERT-size GlobalPointer span extractor",
+    "base_head": "typed span matrix",
+    "raw_only": true,
+    "scanner_free": true,
+    "validator_free": true,
+    "uses_rope": true,
+    "runtime_diffusion": false,
+    "expanded_context_labels": [
+      "STREET_ADDRESS",
+      "CITY",
+      "COUNTY",
+      "DATE_OF_BIRTH",
+      "AGE"
+    ]
+  },
+  "base_model": "OpenMed/OpenMed-PII-mLiteClinical-Base-135M-v1",
+  "notes": [
+    "This release keeps the rc19 weights and ONNX graph but upgrades the bundled decoder and runtime path.",
+    "It fixes Gaelic surname-particle name recovery (`Ní Bhroin`, `Nic ...`, apostrophe surnames after self-cues), removes cue-word name fragments such as `Eirchód`, and preserves the broader contextual masking policy.",
+    "The q8 CPU path is materially faster than the public rc19 bundle on the aligned suites because span decoding now scans only above-threshold candidates and skips expensive repair passes unless the text actually hints at them.",
+    "Fresh unseen contextual holdouts v12, v13, and v14 all score 1.0000 exact F1 on the q8 deployment path.",
+    "The legacy `irish_gov_chatbot_redteam_v2` suite remains at 0.9861 because it intentionally treats public-office street/city details as non-PII; this wider contextual release still masks them by design."
+  ],
+  "labels": [
+    "ACCOUNT_NUMBER",
+    "AGE",
+    "BANK_ROUTING_NUMBER",
+    "CITY",
+    "COUNTY",
+    "CREDIT_DEBIT_CARD",
+    "DATE_OF_BIRTH",
+    "EMAIL",
+    "FIRST_NAME",
+    "LAST_NAME",
+    "PASSPORT_NUMBER",
+    "PHONE_NUMBER",
+    "POSTCODE",
+    "PPSN",
+    "STREET_ADDRESS",
+    "SWIFT_BIC"
+  ],
+  "full": {
+    "core_f1": 1.0,
+    "extended_f1": 1.0,
+    "demographic_holdout_v2_f1": 1.0,
+    "contact_policy_f1": 1.0,
+    "chatbot_redteam_v2_f1": 0.9861111111111112,
+    "chatbot_gap_holdout_v2_f1": 1.0,
+    "multilingual_f1": 0.9333333333333333,
+    "multilingual_ppsn_label_f1": 1.0,
+    "context_redteam_v1_f1": 1.0,
+    "context_redteam_v2_f1": 1.0,
+    "context_redteam_v3_f1": 1.0,
+    "core_examples_per_second": 37.17190773379781,
+    "extended_examples_per_second": 22.601031656884402,
+    "demographic_holdout_v2_examples_per_second": 56.27516807130541,
+    "contact_policy_examples_per_second": 20.47123147395747,
+    "chatbot_redteam_v2_examples_per_second": 29.843260084022578,
+    "chatbot_gap_holdout_v2_examples_per_second": 37.07473771144438,
+    "multilingual_examples_per_second": 58.68937370218514,
+    "context_redteam_v1_examples_per_second": 23.609073299571445,
+    "context_redteam_v2_examples_per_second": 12.737044489760402,
+    "context_redteam_v3_examples_per_second": 17.88102919943181,
+    "location_coverage_v1_f1": 1.0,
+    "location_coverage_v1_examples_per_second": 27.442453278347067,
+    "location_coverage_v2_f1": 1.0,
+    "location_coverage_v2_examples_per_second": 24.3613357869789,
+    "location_coverage_v3_f1": 1.0,
+    "location_coverage_v3_examples_per_second": 35.4459974931921,
+    "numeric_qafix_v2_f1": 1.0,
+    "numeric_qafix_v2_examples_per_second": 29.420131775628487,
+    "context_redteam_v4_f1": 1.0,
+    "context_redteam_v4_examples_per_second": 30.495521507704247,
+    "context_redteam_v5_f1": 1.0,
+    "context_redteam_v5_examples_per_second": 33.33418166561194,
+    "context_redteam_v6_f1": 1.0,
+    "context_redteam_v6_examples_per_second": 38.82008627943923,
+    "context_redteam_v7_f1": 1.0,
+    "context_redteam_v7_examples_per_second": 41.1670461610147,
+    "context_redteam_v8_f1": 1.0,
+    "context_redteam_v8_examples_per_second": 83.67568116564722,
+    "context_redteam_v9_f1": 1.0,
+    "context_redteam_v9_exact_f1": 1.0,
+    "context_redteam_v9_examples_per_second": 88.87266377516937,
+    "context_redteam_v10_f1": 1.0,
+    "context_redteam_v10_examples_per_second": 88.13695906305226,
+    "context_redteam_v11_f1": 1.0,
+    "context_redteam_v11_examples_per_second": 86.98335983822658
+  },
+  "onnx_q8": {
+    "core_f1": 1.0,
+    "extended_f1": 1.0,
+    "demographic_holdout_v2_f1": 1.0,
+    "contact_policy_f1": 1.0,
+    "chatbot_redteam_v2_f1": 0.9861111111111112,
+    "chatbot_gap_holdout_v2_f1": 1.0,
+    "multilingual_f1": 0.9333333333333333,
+    "multilingual_ppsn_label_f1": 1.0,
+    "context_redteam_v1_f1": 1.0,
+    "context_redteam_v2_f1": 1.0,
+    "context_redteam_v3_f1": 1.0,
+    "core_examples_per_second": 181.88206667840814,
+    "extended_examples_per_second": 78.77478690814097,
+    "demographic_holdout_v2_examples_per_second": 92.56832502112522,
+    "contact_policy_examples_per_second": 150.66496558174578,
+    "chatbot_redteam_v2_examples_per_second": 117.00163598408656,
+    "chatbot_gap_holdout_v2_examples_per_second": 118.2172706176689,
+    "multilingual_examples_per_second": 155.21078613421756,
+    "context_redteam_v1_examples_per_second": 77.35126547341245,
+    "context_redteam_v2_examples_per_second": 83.42976656780596,
+    "context_redteam_v3_examples_per_second": 115.78405703667622,
+    "location_coverage_v1_f1": 1.0,
+    "location_coverage_v1_examples_per_second": 86.67576551780107,
+    "location_coverage_v2_f1": 1.0,
+    "location_coverage_v2_examples_per_second": 63.49649295628558,
+    "location_coverage_v3_f1": 1.0,
+    "location_coverage_v3_examples_per_second": 103.87880730624308,
+    "numeric_qafix_v2_f1": 1.0,
+    "numeric_qafix_v2_examples_per_second": 138.13081928103207,
+    "context_redteam_v4_f1": 1.0,
+    "context_redteam_v4_examples_per_second": 115.20604478400188,
+    "context_redteam_v5_f1": 1.0,
+    "context_redteam_v5_examples_per_second": 144.35657204962527,
+    "context_redteam_v6_f1": 1.0,
+    "context_redteam_v6_examples_per_second": 158.02088849696304,
+    "context_redteam_v7_f1": 1.0,
+    "context_redteam_v7_examples_per_second": 115.86553627218991,
+    "context_redteam_v8_f1": 1.0,
+    "context_redteam_v8_examples_per_second": 102.16264190462925,
+    "context_redteam_v9_f1": 1.0,
+    "context_redteam_v9_exact_f1": 1.0,
+    "context_redteam_v9_examples_per_second": 146.4675637488471,
+    "context_redteam_v10_f1": 1.0,
+    "context_redteam_v10_exact_f1": 1.0,
+    "context_redteam_v10_examples_per_second": 106.68196467882363,
+    "context_redteam_v11_f1": 1.0,
+    "context_redteam_v11_exact_f1": 1.0,
+    "context_redteam_v11_examples_per_second": 211.542361065222,
+    "context_holdout_v12_exact_f1": 1.0,
+    "context_holdout_v12_examples_per_second": 77.68764668742236,
+    "context_holdout_v13_exact_f1": 1.0,
+    "context_holdout_v13_examples_per_second": 116.31896591646488,
+    "context_holdout_v14_exact_f1": 1.0,
+    "context_holdout_v14_examples_per_second": 126.55285725261149,
+    "runtime_profile_f1": 0.8260363297624592,
+    "runtime_profile_examples_per_second": 84.94660779271977
+  },
+  "comparison": {
+    "public_contextpii_rc8_onnx_q8": {
+      "core_f1": 1.0,
+      "extended_f1": 1.0,
+      "contact_policy_f1": 1.0,
+      "chatbot_redteam_v2_f1": 0.9861111111111112,
+      "multilingual_f1": 0.9333333333333333,
+      "multilingual_ppsn_label_f1": 1.0,
+      "context_redteam_v2_f1": 1.0,
+      "context_redteam_v3_f1": 0.8717948717948718,
+      "core_examples_per_second": 128.88250222316304
+    },
+    "public_contextpii_rc7_onnx_q8": {
+      "core_f1": 1.0,
+      "contact_policy_f1": 1.0,
+      "context_redteam_v2_f1": null,
+      "multilingual_f1": 0.9333333333333333,
+      "core_examples_per_second": 88.99815744185265
+    },
+    "public_contextpii_rc4_onnx_q8": {
+      "core_f1": 0.9934640522875817,
+      "extended_f1": 1.0,
+      "demographic_holdout_v2_f1": 1.0,
+      "contact_policy_f1": 1.0,
+      "chatbot_redteam_v2_f1": 0.9861111111111112,
+      "chatbot_gap_holdout_v2_f1": 1.0,
+      "multilingual_f1": 0.9333333333333333,
+      "multilingual_ppsn_label_f1": 1.0,
+      "core_examples_per_second": 61.49696721632529,
+      "extended_examples_per_second": 98.75019005245319,
+      "demographic_holdout_v2_examples_per_second": 90.7806851088372,
+      "contact_policy_examples_per_second": 101.91338377846299,
+      "chatbot_redteam_v2_examples_per_second": 13.042183136147377,
+      "chatbot_gap_holdout_v2_examples_per_second": 30.728912108647304,
+      "multilingual_examples_per_second": 33.54466395109805,
+      "location_coverage_v1_f1": null
+    },
+    "public_diffmask_rc6_onnx_q8": {
+      "core_f1": 0.9733333333333333,
+      "multilingual_f1": 0.9273743016759777,
+      "core_examples_per_second": 130.34154354965295
+    },
+    "public_globalpointer_rc4_onnx_q8": {
+      "core_f1": 1.0,
+      "multilingual_f1": 0.9333333333333333,
+      "core_examples_per_second": 221.57427241189015
+    },
+    "public_contextpii_rc9_onnx_q8": {
+      "core_f1": 1.0,
+      "contact_policy_f1": 1.0,
+      "chatbot_redteam_v2_f1": 0.9861111111111112,
+      "multilingual_f1": 0.9333333333333333,
+      "context_redteam_v4_f1": 0.8533333333333333,
+      "core_examples_per_second": 125.82111537540908
+    },
+    "public_contextpii_rc10_onnx_q8": {
+      "core_f1": 1.0,
+      "contact_policy_f1": 1.0,
+      "chatbot_redteam_v2_f1": 0.9861111111111112,
+      "multilingual_f1": 0.9333333333333333,
+      "context_redteam_v4_f1": 1.0,
+      "core_examples_per_second": 125.82111537540908
+    },
+    "public_contextpii_rc11_onnx_q8": {
+      "core_f1": 1.0,
+      "contact_policy_f1": 1.0,
+      "chatbot_redteam_v2_f1": 0.9861111111111112,
+      "multilingual_f1": 0.9333333333333333,
+      "context_redteam_v5_f1": 1.0,
+      "core_examples_per_second": 94.09271075291537
+    },
+    "public_contextpii_rc12_onnx_q8": {
+      "core_f1": 1.0,
+      "contact_policy_f1": 1.0,
+      "chatbot_redteam_v2_f1": 0.9793103448275862,
+      "multilingual_f1": 0.9333333333333333,
+      "context_redteam_v6_f1": 1.0,
+      "core_examples_per_second": 73.59921479476388
+    },
+    "public_contextpii_rc13_onnx_q8": {
+      "core_f1": 1.0,
+      "contact_policy_f1": 1.0,
+      "chatbot_redteam_v2_f1": 0.9793103448275862,
+      "multilingual_f1": 0.9333333333333333,
+      "context_redteam_v7_f1": 1.0,
+      "core_examples_per_second": 126.08782280133414
+    },
+    "public_contextpii_rc15_onnx_q8": {
+      "repo": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc15",
+      "core_f1": 1.0,
+      "multilingual_f1": 0.9333333333333333,
+      "core_examples_per_second": 125.5054
+    },
+    "public_contextpii_rc16_onnx_q8": {
+      "repo": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc16",
+      "core_f1": 1.0,
+      "multilingual_f1": 0.9333333333333333,
+      "core_examples_per_second": 68.0709
+    },
+    "public_contextpii_rc17_onnx_q8": {
+      "repo": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc17",
+      "core_f1": 1.0,
+      "multilingual_f1": 0.9333333333333333,
+      "core_examples_per_second": 70.9494
+    },
+    "public_contextpii_rc18_onnx_q8": {
+      "repo": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc18",
+      "core_f1": 1.0,
+      "multilingual_f1": 0.9333333333333333,
+      "core_examples_per_second": 111.3135
+    }
+  }
+}

eval/benchmark_summary.md

@@ -0,0 +1,18 @@
+# IrishCore-GlobalPointer-ContextPII-135M-v1-rc20
+
+## ONNX q8
+
+| Suite | F1 | Examples/s |
+| --- | ---: | ---: |
+| Irish core | 1.0000 | 181.8821 |
+| Irish extended | 1.0000 | 78.7748 |
+| Gov contact policy v1 | 1.0000 | 150.6650 |
+| Gov chatbot red-team v2 | 0.9861 | 117.0016 |
+| Gov chatbot gap holdout v2 | 1.0000 | 118.2173 |
+| Context red-team v11 exact | 1.0000 | 211.5424 |
+| Context holdout v12 exact | 1.0000 | 77.6876 |
+| Context holdout v13 exact | 1.0000 | 116.3190 |
+| Context holdout v14 exact | 1.0000 | 126.5529 |
+| Multilingual PPSN overall | 0.9333 | 155.2108 |
+| Multilingual PPSN label-only | 1.0000 | — |
+| Runtime profile source | 0.8260 | 84.9466 |

eval/full_diffmask_fresh_holdout_v1.json

@@ -0,0 +1,85 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc1",
+  "input": "diffmask_fresh_holdout_v1.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 20,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.6364284890005365,
+  "examples_per_second": 31.425368828803546,
+  "overall": {
+    "precision": 1.0,
+    "recall": 0.96875,
+    "f1": 0.9841269841269841,
+    "tp": 31,
+    "fp": 0,
+    "fn": 1
+  },
+  "by_label": {
+    "ACCOUNT_NUMBER": {
+      "precision": 1.0,
+      "recall": 0.5,
+      "f1": 0.6666666666666666,
+      "tp": 1,
+      "fp": 0,
+      "fn": 1
+    },
+    "CREDIT_DEBIT_CARD": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "release_backend": "full"
+}

eval/full_diffmask_gap_uat_exact_v1.json

@@ -0,0 +1,53 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc1",
+  "input": "diffmask_gap_uat_exact_v1.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 16,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.549252360011451,
+  "examples_per_second": 29.130507513279376,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 17,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 5,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "release_backend": "full"
+}

eval/full_globalpointer_context_redteam_v1.json

@@ -0,0 +1,109 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc9",
+  "input": "eval/globalpointer_context_redteam_v1.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 14,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.5929923560470343,
+  "examples_per_second": 23.609073299571445,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 54,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 10,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "backend": "full"
+}

eval/full_globalpointer_context_redteam_v10.json

@@ -0,0 +1,100 @@
+{
+  "model": "release/IrishCore-GlobalPointer-ContextPII-135M-v1-rc16",
+  "input": "eval/globalpointer_context_redteam_v10.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 64,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.7261425930773839,
+  "examples_per_second": 88.13695906305226,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 129,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 28,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 12,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 15,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 9,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 21,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 7,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 17,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_globalpointer_context_redteam_v11.json

@@ -0,0 +1,100 @@
+{
+  "model": "release/IrishCore-GlobalPointer-ContextPII-135M-v1-rc17",
+  "input": "eval/globalpointer_context_redteam_v11.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 70,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.8047516229562461,
+  "examples_per_second": 86.98335983822658,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 140,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 31,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 13,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 15,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 9,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 23,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 7,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 22,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_globalpointer_context_redteam_v2.json

@@ -0,0 +1,69 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc9",
+  "input": "eval/globalpointer_context_redteam_v2.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 6,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.47106689505744725,
+  "examples_per_second": 12.737044489760402,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 13,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "backend": "full"
+}

eval/full_globalpointer_context_redteam_v3.json

@@ -0,0 +1,77 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc10",
+  "input": "eval/globalpointer_context_redteam_v3.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 12,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.6711023099487647,
+  "examples_per_second": 17.88102919943181,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 22,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 7,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "backend": "full"
+}

eval/full_globalpointer_context_redteam_v4.json

@@ -0,0 +1,101 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc10",
+  "input": "eval/globalpointer_context_redteam_v4.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 21,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.6886257050791755,
+  "examples_per_second": 30.495521507704247,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 43,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 10,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 5,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "backend": "full"
+}

eval/full_globalpointer_context_redteam_v5.json

@@ -0,0 +1,100 @@
+{
+  "model": "models/irishcore-globalpointer-135m-b01-extendedv1-e025",
+  "input": "eval/globalpointer_context_redteam_v5.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 25,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.7499809130094945,
+  "examples_per_second": 33.33418166561194,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 47,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 10,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 5,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_globalpointer_context_redteam_v6.json

@@ -0,0 +1,100 @@
+{
+  "model": "models/irishcore-globalpointer-135m-b01-extendedv1-e025",
+  "input": "eval/globalpointer_context_redteam_v6.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 38,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.9788746919948608,
+  "examples_per_second": 38.82008627943923,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 72,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 5,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 14,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 10,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 7,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 10,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 9,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_globalpointer_context_redteam_v7.json

@@ -0,0 +1,100 @@
+{
+  "model": "models/irishcore-globalpointer-135m-b01-extendedv1-e025",
+  "input": "eval/globalpointer_context_redteam_v7.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 41,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.9959422359243035,
+  "examples_per_second": 41.1670461610147,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 84,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 5,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 17,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 10,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 7,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 13,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 12,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_globalpointer_context_redteam_v8.json

@@ -0,0 +1,100 @@
+{
+  "model": "release/IrishCore-GlobalPointer-ContextPII-135M-v1-rc14",
+  "input": "eval/globalpointer_context_redteam_v8.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 51,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.6094960840418935,
+  "examples_per_second": 83.67568116564722,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 113,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 5,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 25,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 10,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 10,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 9,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 19,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 15,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_globalpointer_context_redteam_v9.json

@@ -0,0 +1,100 @@
+{
+  "model": "release/IrishCore-GlobalPointer-ContextPII-135M-v1-rc15",
+  "input": "eval/globalpointer_context_redteam_v9.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 60,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.6751232319511473,
+  "examples_per_second": 88.87266377516937,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 118,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 25,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 10,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 14,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 9,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 19,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 15,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_globalpointer_context_redteam_v9_exact.json

@@ -0,0 +1,100 @@
+{
+  "model": "release/IrishCore-GlobalPointer-ContextPII-135M-v1-rc15",
+  "input": "eval/globalpointer_context_redteam_v9.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 60,
+  "min_score": 0.5,
+  "iou_threshold": 1.0,
+  "elapsed_seconds": 0.6622731270035729,
+  "examples_per_second": 90.59706268238226,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 118,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 25,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 10,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 14,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 9,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 19,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 15,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_globalpointer_demographic_patch_v2_test.json

@@ -0,0 +1,108 @@
+{
+  "model": "models/irishcore-globalpointer-135m-b01-extendedv1-e025",
+  "input": "eval/globalpointer_demographic_patch_v2_test.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 600,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 10.661896189092658,
+  "examples_per_second": 56.27516807130541,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 2470,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 287,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 286,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 286,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 304,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 85,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 194,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 194,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 177,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 286,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 85,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 286,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_globalpointer_location_coverage_v1.json

@@ -0,0 +1,61 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc9",
+  "input": "eval/globalpointer_location_coverage_v1.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 18,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.6559180339099839,
+  "examples_per_second": 27.442453278347067,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 56,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 14,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 16,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 12,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 12,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "backend": "full"
+}

eval/full_globalpointer_location_coverage_v2.json

@@ -0,0 +1,61 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc9",
+  "input": "eval/globalpointer_location_coverage_v2.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 24,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.9851676529506221,
+  "examples_per_second": 24.3613357869789,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 68,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 20,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 22,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 12,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 12,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "backend": "full"
+}

eval/full_globalpointer_location_coverage_v3.json

@@ -0,0 +1,61 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc9",
+  "input": "eval/globalpointer_location_coverage_v3.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 30,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.8463578999508172,
+  "examples_per_second": 35.4459974931921,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 82,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 26,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 28,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 13,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 13,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "backend": "full"
+}

eval/full_irish_core_pii_v1.json

@@ -0,0 +1,108 @@
+{
+  "model": "models/irishcore-globalpointer-135m-b01-extendedv1-e025",
+  "input": "eval/irish_core_pii_v1.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 37,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.9953753319568932,
+  "examples_per_second": 37.17190773379781,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 76,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "ACCOUNT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "BANK_ROUTING_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "CREDIT_DEBIT_CARD": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 19,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 19,
+      "fp": 0,
+      "fn": 0
+    },
+    "PASSPORT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 12,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "SWIFT_BIC": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_irish_dllm_hardening_exact_v1.json

@@ -0,0 +1,101 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc1",
+  "input": "irish_dllm_hardening_exact_v1.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 14,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.5248716080095619,
+  "examples_per_second": 26.673189759856385,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 20,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "ACCOUNT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "BANK_ROUTING_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "CREDIT_DEBIT_CARD": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "SWIFT_BIC": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "release_backend": "full"
+}

eval/full_irish_extended_pii_v1.json

@@ -0,0 +1,108 @@
+{
+  "model": "models/irishcore-globalpointer-135m-b01-extendedv1-e025",
+  "input": "eval/irish_extended_pii_v1.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 14,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.6194407499860972,
+  "examples_per_second": 22.601031656884402,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 50,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 5,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_irish_gov_chatbot_gap_holdout_v1.json

@@ -0,0 +1,258 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc1",
+  "family": "globalpointer",
+  "backend": "pt",
+  "input": "irish_gov_chatbot_gap_holdout_v1.jsonl",
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 413,
+    "fp": 0,
+    "fn": 0
+  },
+  "exact": {
+    "precision": 0.9878934624697336,
+    "recall": 0.9878934624697336,
+    "f1": 0.9878934624697336,
+    "tp": 408,
+    "fp": 5,
+    "fn": 5
+  },
+  "by_label": {
+    "ACCOUNT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 16,
+      "fp": 0,
+      "fn": 0
+    },
+    "BANK_ROUTING_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 23,
+      "fp": 0,
+      "fn": 0
+    },
+    "CREDIT_DEBIT_CARD": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 50,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 70,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 70,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 72,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 18,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 72,
+      "fp": 0,
+      "fn": 0
+    },
+    "SWIFT_BIC": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 16,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "by_language": {
+    "en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 230,
+      "fp": 0,
+      "fn": 0
+    },
+    "ga": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 183,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "by_role": {
+    "assistant": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 72,
+      "fp": 0,
+      "fn": 0
+    },
+    "mixed": {
+      "precision": 0.0,
+      "recall": 0.0,
+      "f1": 0.0,
+      "tp": 0,
+      "fp": 0,
+      "fn": 0
+    },
+    "user": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 341,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "by_source_type": {
+    "assistant_contact_echo_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 32,
+      "fp": 0,
+      "fn": 0
+    },
+    "assistant_contact_echo_ga": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 40,
+      "fp": 0,
+      "fn": 0
+    },
+    "negative_en": {
+      "precision": 0.0,
+      "recall": 0.0,
+      "f1": 0.0,
+      "tp": 0,
+      "fp": 0,
+      "fn": 0
+    },
+    "negative_ga": {
+      "precision": 0.0,
+      "recall": 0.0,
+      "f1": 0.0,
+      "tp": 0,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_card_email_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 12,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_name_email_ppsn_phone_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 80,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_name_email_ppsn_phone_ga": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 50,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_name_ppsn_phone_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 56,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_name_ppsn_phone_ga": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 56,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_payment_name_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 32,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_payment_name_ga": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 32,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_sort_code_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 18,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_sort_code_ga": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 5,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "failure_count": 0,
+  "failures": []
+}

eval/full_irish_gov_chatbot_gap_holdout_v2.json

@@ -0,0 +1,92 @@
+{
+  "model": "models/irishcore-globalpointer-135m-b01-extendedv1-e025",
+  "input": "eval/irish_gov_chatbot_gap_holdout_v2.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 160,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 4.31560706498567,
+  "examples_per_second": 37.07473771144438,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 652,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "ACCOUNT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 38,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 104,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 68,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 68,
+      "fp": 0,
+      "fn": 0
+    },
+    "PASSPORT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 33,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 101,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 101,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 101,
+      "fp": 0,
+      "fn": 0
+    },
+    "SWIFT_BIC": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 38,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_irish_gov_chatbot_redteam_assistant_v2.json

@@ -0,0 +1,84 @@
+{
+  "model": "models/irishcore-globalpointer-135m-b01-extendedv1-e025",
+  "input": "eval/irish_gov_chatbot_redteam_assistant_v2.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 9,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.16110201692208648,
+  "examples_per_second": 55.86522237243408,
+  "overall": {
+    "precision": 0.9375,
+    "recall": 1.0,
+    "f1": 0.967741935483871,
+    "tp": 30,
+    "fp": 2,
+    "fn": 0
+  },
+  "by_label": {
+    "ACCOUNT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "SWIFT_BIC": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_irish_gov_chatbot_redteam_user_v2.json

@@ -0,0 +1,108 @@
+{
+  "model": "models/irishcore-globalpointer-135m-b01-extendedv1-e025",
+  "input": "eval/irish_gov_chatbot_redteam_user_v2.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 10,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.1798157700104639,
+  "examples_per_second": 55.612474920403685,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 41,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "ACCOUNT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "BANK_ROUTING_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "CREDIT_DEBIT_CARD": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 5,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 5,
+      "fp": 0,
+      "fn": 0
+    },
+    "PASSPORT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 9,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 7,
+      "fp": 0,
+      "fn": 0
+    },
+    "SWIFT_BIC": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_irish_gov_chatbot_redteam_v1.json

@@ -0,0 +1,362 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc1",
+  "family": "globalpointer",
+  "backend": "pt",
+  "input": "irish_gov_chatbot_redteam_v1.jsonl",
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 161,
+    "fp": 0,
+    "fn": 0
+  },
+  "exact": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 161,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "ACCOUNT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 9,
+      "fp": 0,
+      "fn": 0
+    },
+    "BANK_ROUTING_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "CREDIT_DEBIT_CARD": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 16,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 18,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 18,
+      "fp": 0,
+      "fn": 0
+    },
+    "PASSPORT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 36,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 11,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 34,
+      "fp": 0,
+      "fn": 0
+    },
+    "SWIFT_BIC": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 9,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "by_language": {
+    "en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 99,
+      "fp": 0,
+      "fn": 0
+    },
+    "ga": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 62,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "by_role": {
+    "assistant": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 56,
+      "fp": 0,
+      "fn": 0
+    },
+    "mixed": {
+      "precision": 0.0,
+      "recall": 0.0,
+      "f1": 0.0,
+      "tp": 0,
+      "fp": 0,
+      "fn": 0
+    },
+    "user": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 105,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "by_source_type": {
+    "assistant_centre_block_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "assistant_contact_block_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "assistant_contact_ga": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "assistant_echo_user_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 15,
+      "fp": 0,
+      "fn": 0
+    },
+    "assistant_echo_user_ga": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 15,
+      "fp": 0,
+      "fn": 0
+    },
+    "assistant_location_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 12,
+      "fp": 0,
+      "fn": 0
+    },
+    "assistant_mailbox_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "assistant_payment_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "negative_date_en": {
+      "precision": 0.0,
+      "recall": 0.0,
+      "f1": 0.0,
+      "tp": 0,
+      "fp": 0,
+      "fn": 0
+    },
+    "negative_date_ga": {
+      "precision": 0.0,
+      "recall": 0.0,
+      "f1": 0.0,
+      "tp": 0,
+      "fp": 0,
+      "fn": 0
+    },
+    "negative_direct_debit_en": {
+      "precision": 0.0,
+      "recall": 0.0,
+      "f1": 0.0,
+      "tp": 0,
+      "fp": 0,
+      "fn": 0
+    },
+    "negative_hours_en": {
+      "precision": 0.0,
+      "recall": 0.0,
+      "f1": 0.0,
+      "tp": 0,
+      "fp": 0,
+      "fn": 0
+    },
+    "negative_long_ppsn_en": {
+      "precision": 0.0,
+      "recall": 0.0,
+      "f1": 0.0,
+      "tp": 0,
+      "fp": 0,
+      "fn": 0
+    },
+    "negative_scheme_ga": {
+      "precision": 0.0,
+      "recall": 0.0,
+      "f1": 0.0,
+      "tp": 0,
+      "fp": 0,
+      "fn": 0
+    },
+    "negative_short_ppsn_en": {
+      "precision": 0.0,
+      "recall": 0.0,
+      "f1": 0.0,
+      "tp": 0,
+      "fp": 0,
+      "fn": 0
+    },
+    "negative_year_letter_ga": {
+      "precision": 0.0,
+      "recall": 0.0,
+      "f1": 0.0,
+      "tp": 0,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_allowance_mixed_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 24,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_allowance_mixed_ga": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 24,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_bare_ppsn_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_bare_ppsn_ga": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_card_email_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_passport_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 12,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_payment_en": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 12,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_payment_ga": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 12,
+      "fp": 0,
+      "fn": 0
+    },
+    "user_sort_code_ga": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "failure_count": 0,
+  "failures": []
+}

eval/full_irish_gov_chatbot_redteam_v2.json

@@ -0,0 +1,108 @@
+{
+  "model": "models/irishcore-globalpointer-135m-b01-extendedv1-e025",
+  "input": "eval/irish_gov_chatbot_redteam_v2.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 25,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.8377100869547576,
+  "examples_per_second": 29.843260084022578,
+  "overall": {
+    "precision": 0.9726027397260274,
+    "recall": 1.0,
+    "f1": 0.9861111111111112,
+    "tp": 71,
+    "fp": 2,
+    "fn": 0
+  },
+  "by_label": {
+    "ACCOUNT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "BANK_ROUTING_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "CREDIT_DEBIT_CARD": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 10,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 7,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 7,
+      "fp": 0,
+      "fn": 0
+    },
+    "PASSPORT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 17,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 7,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 11,
+      "fp": 0,
+      "fn": 0
+    },
+    "SWIFT_BIC": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_irish_gov_contact_policy_v1.json

@@ -0,0 +1,76 @@
+{
+  "model": "models/irishcore-globalpointer-135m-b01-extendedv1-e025",
+  "input": "eval/irish_gov_contact_policy_v1.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 12,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.586188476998359,
+  "examples_per_second": 20.47123147395747,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 30,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_irish_numeric_qafix_v2.json

@@ -0,0 +1,45 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc9",
+  "input": "eval/irish_numeric_qafix_v2.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 19,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.6458162779454142,
+  "examples_per_second": 29.420131775628487,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 14,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "BANK_ROUTING_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 5,
+      "fp": 0,
+      "fn": 0
+    },
+    "PASSPORT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 5,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "backend": "full"
+}

eval/full_irish_ppsn_phone_edge_v1.json

@@ -0,0 +1,37 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc1",
+  "input": "irish_ppsn_phone_edge_v1.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 22,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.41967142606154084,
+  "examples_per_second": 52.42196307349719,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 19,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 13,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "release_backend": "full"
+}

eval/full_irish_remaining_gaps_v2.json

@@ -0,0 +1,36 @@
+{
+  "model": "models/irishcore-globalpointer-135m-b01-extendedv1-e025",
+  "input": "eval/irish_remaining_gaps_v2.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 6,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.08656914997845888,
+  "examples_per_second": 69.30875492589436,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 5,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "PASSPORT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_multilingual_ppsn_v1_all.json

@@ -0,0 +1,28 @@
+{
+  "model": "models/irishcore-globalpointer-135m-b01-extendedv1-e025",
+  "input": "eval/multilingual_ppsn_v1_all.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 168,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 2.862528417026624,
+  "examples_per_second": 58.68937370218514,
+  "overall": {
+    "precision": 0.875,
+    "recall": 1.0,
+    "f1": 0.9333333333333333,
+    "tp": 84,
+    "fp": 12,
+    "fn": 0
+  },
+  "by_label": {
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 84,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/full_runtime_profile_source.json

@@ -0,0 +1,29 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc1",
+  "input": "runtime_profile_source.jsonl",
+  "loader_type": "global_pointer_pt",
+  "examples": 3223,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 46.959111439064145,
+  "examples_per_second": 68.63417771825351,
+  "overall": {
+    "precision": 0.585127996749289,
+    "recall": 0.40597688187200454,
+    "f1": 0.47936085219707064,
+    "tp": 1440,
+    "fp": 1021,
+    "fn": 2107
+  },
+  "by_label": {
+    "PPSN": {
+      "precision": 0.9320388349514563,
+      "recall": 0.40597688187200454,
+      "f1": 0.5655930871956009,
+      "tp": 1440,
+      "fp": 105,
+      "fn": 2107
+    }
+  },
+  "release_backend": "full"
+}

eval/label_inventory.json

@@ -0,0 +1,20 @@
+{
+  "labels": [
+    "ACCOUNT_NUMBER",
+    "AGE",
+    "BANK_ROUTING_NUMBER",
+    "CITY",
+    "COUNTY",
+    "CREDIT_DEBIT_CARD",
+    "DATE_OF_BIRTH",
+    "EMAIL",
+    "FIRST_NAME",
+    "LAST_NAME",
+    "PASSPORT_NUMBER",
+    "PHONE_NUMBER",
+    "POSTCODE",
+    "PPSN",
+    "STREET_ADDRESS",
+    "SWIFT_BIC"
+  ]
+}

eval/q8_diffmask_fresh_holdout_v1.json

@@ -0,0 +1,85 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc1",
+  "input": "diffmask_fresh_holdout_v1.jsonl",
+  "loader_type": "global_pointer_onnx",
+  "examples": 20,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.13704864599276334,
+  "examples_per_second": 145.93358332818605,
+  "overall": {
+    "precision": 1.0,
+    "recall": 0.96875,
+    "f1": 0.9841269841269841,
+    "tp": 31,
+    "fp": 0,
+    "fn": 1
+  },
+  "by_label": {
+    "ACCOUNT_NUMBER": {
+      "precision": 1.0,
+      "recall": 0.5,
+      "f1": 0.6666666666666666,
+      "tp": 1,
+      "fp": 0,
+      "fn": 1
+    },
+    "CREDIT_DEBIT_CARD": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "release_backend": "onnx_q8"
+}

eval/q8_diffmask_gap_uat_exact_v1.json

@@ -0,0 +1,53 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc1",
+  "input": "diffmask_gap_uat_exact_v1.jsonl",
+  "loader_type": "global_pointer_onnx",
+  "examples": 16,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.08481148700229824,
+  "examples_per_second": 188.65369026681998,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 17,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 3,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 5,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "release_backend": "onnx_q8"
+}

eval/q8_globalpointer_context_holdout_v12_exact.json

@@ -0,0 +1,140 @@
+{
+  "model": "release/IrishCore-GlobalPointer-ContextPII-135M-v1-rc19",
+  "input": "eval/globalpointer_context_holdout_v12.jsonl",
+  "loader_type": "global_pointer_onnx",
+  "examples": 22,
+  "min_score": 0.5,
+  "iou_threshold": 1.0,
+  "elapsed_seconds": 0.2831853060051799,
+  "examples_per_second": 77.68764668742236,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 60,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "ACCOUNT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "CREDIT_DEBIT_CARD": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "PASSPORT_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "SWIFT_BIC": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/q8_globalpointer_context_holdout_v13_exact.json

@@ -0,0 +1,108 @@
+{
+  "model": "release/IrishCore-GlobalPointer-ContextPII-135M-v1-rc19",
+  "input": "eval/globalpointer_context_holdout_v13.jsonl",
+  "loader_type": "global_pointer_onnx",
+  "examples": 10,
+  "min_score": 0.5,
+  "iou_threshold": 1.0,
+  "elapsed_seconds": 0.08597050292883068,
+  "examples_per_second": 116.31896591646488,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 36,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/q8_globalpointer_context_holdout_v14_exact.json

@@ -0,0 +1,84 @@
+{
+  "model": "release/IrishCore-GlobalPointer-ContextPII-135M-v1-rc19",
+  "input": "eval/globalpointer_context_holdout_v14.jsonl",
+  "loader_type": "global_pointer_onnx",
+  "examples": 10,
+  "min_score": 0.5,
+  "iou_threshold": 1.0,
+  "elapsed_seconds": 0.07901836605742574,
+  "examples_per_second": 126.55285725261149,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 42,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 1,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 5,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 6,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 9,
+      "fp": 0,
+      "fn": 0
+    }
+  }
+}

eval/q8_globalpointer_context_redteam_v1.json

@@ -0,0 +1,109 @@
+{
+  "model": "temsa/IrishCore-GlobalPointer-ContextPII-135M-v1-rc9",
+  "input": "eval/globalpointer_context_redteam_v1.jsonl",
+  "loader_type": "global_pointer_onnx",
+  "examples": 14,
+  "min_score": 0.5,
+  "iou_threshold": 0.5,
+  "elapsed_seconds": 0.1809925140114501,
+  "examples_per_second": 77.35126547341245,
+  "overall": {
+    "precision": 1.0,
+    "recall": 1.0,
+    "f1": 1.0,
+    "tp": 54,
+    "fp": 0,
+    "fn": 0
+  },
+  "by_label": {
+    "AGE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "CITY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "COUNTY": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 10,
+      "fp": 0,
+      "fn": 0
+    },
+    "DATE_OF_BIRTH": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "EMAIL": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "FIRST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "LAST_NAME": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "PHONE_NUMBER": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 4,
+      "fp": 0,
+      "fn": 0
+    },
+    "POSTCODE": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    },
+    "PPSN": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 2,
+      "fp": 0,
+      "fn": 0
+    },
+    "STREET_ADDRESS": {
+      "precision": 1.0,
+      "recall": 1.0,
+      "f1": 1.0,
+      "tp": 8,
+      "fp": 0,
+      "fn": 0
+    }
+  },
+  "backend": "onnx_q8"
+}