Initial public commit

Co-authored-by: mlabonne <mlabonne@users.noreply.huggingface.co>
Co-authored-by: mini97 <mini97@users.noreply.huggingface.co>

.gitattributes

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

LICENSE

@@ -0,0 +1,71 @@
+LFM Open License v1.0 
+
+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 this document.
+
+"Licensor" shall mean Liquid AI, Inc.
+
+"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.
+
+"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.
+
+"Commercial Use" shall mean any use of the Work for direct or indirect commercial advantage or monetary compensation.
+
+"Qualified Non-Profit Organization" shall mean a Legal Entity that is organized and operated exclusively for religious, charitable, scientific, testing for public safety, literary, or educational purposes, and which is exempt from federal income tax under Section 501(c)(3) of the United States Internal Revenue Code of 1986, as amended, or any equivalent non-profit or charitable organization in a foreign jurisdiction.
+
+"Non-Commercial or Research Purposes" shall mean purposes that do not involve any use of the Work or a Derivative Work for Commercial Use.
+
+"Threshold" shall mean annual revenue of 10 million United States dollars ($10,000,000) or more.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, including the Commercial Use limitation set forth in Section 5, 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, including the Commercial Use limitation set forth in Section 5, 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. Commercial Use Limitation.
+
+(a) The rights granted under this License for Commercial Use are conditioned upon You or Your Legal Entity not exceeding the Threshold.
+
+(b) Any Commercial Use of the Work or a Derivative Work by a Legal Entity that exceeds the Threshold is not licensed under this Agreement.
+
+(c) The Threshold shall not apply to a Qualified Non-Profit Organization's use of the Work or a Derivative Work for Non-Commercial or Research Purposes.
+
+6. 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.
+
+7. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except for the reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+8. 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.
+
+9. 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.
+
+10. 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.
+
+11. Termination. This License will terminate automatically and immediately if You fail to comply with any of its terms and conditions. Upon termination, You must cease all use of the Work and any Derivative Works and delete all copies in Your possession.
+
+END OF TERMS AND CONDITIONS

README.md

@@ -0,0 +1,129 @@
+---
+language:
+- en
+- de
+- fr
+- es
+- it
+- pt
+- nl
+- ru
+- ja
+- zh
+- ko
+tags:
+- liquid
+- lfm2
+- lfm2.5
+- bidirectional
+- masked-lm
+- encoder
+- grammatical-error-correction
+- gec
+- spell-check
+- token-classification
+- gector
+library_name: transformers
+license: other
+license_name: lfm1.0
+license_link: LICENSE
+pipeline_tag: token-classification
+base_model:
+    - LiquidAI/LFM2.5-Encoder-350M
+---
+
+<div align="center">
+  <img 
+    src="https://cdn-uploads.huggingface.co/production/uploads/61b8e2ba285851687028d395/2b08LKpev0DNEk6DlnWkY.png" 
+    alt="Liquid AI" 
+    style="width: 100%; max-width: 100%; height: auto; display: inline-block; margin-bottom: 0.5em; margin-top: 0.5em;"
+  />
+  <div style="display: flex; justify-content: center; gap: 0.5em; margin-bottom: 1em;">
+    <a href="https://playground.liquid.ai/"><strong>Try LFM</strong></a> • 
+    <a href="https://docs.liquid.ai/lfm/getting-started/welcome"><strong>Docs</strong></a> • 
+    <a href="https://leap.liquid.ai/"><strong>LEAP</strong></a> • 
+    <a href="https://discord.com/invite/liquid-ai"><strong>Discord</strong></a>
+  </div>
+</div>
+
+# LFM2.5-Encoder-350-Spellchecker
+
+A full fine-tune of [LFM2.5-Encoder-350M](https://huggingface.co/LiquidAI/LFM2.5-Encoder-350M) with a subword-level **GECToR-style grammatical-error-correction tagger**. 
+It covers grammar, spelling, punctuation, and casing in English. 
+
+Find more details about our encoders in our [blog post](https://www.liquid.ai/blog/lfm2-5-encoders).
+
+> [!NOTE]
+> 💻 **Demos**: Try this fine-tuned model running in a CPU-only Hugging Face space:
+> **[Spell checking](https://huggingface.co/spaces/LiquidAI/spellchecker)** — correct misspellings token by token.
+
+## Usage
+
+> ⚠️ Loads custom code via `trust_remote_code=True` (the model wraps a `trust_remote_code` encoder).
+
+Install the required packages:
+
+```bash
+pip install torch transformers
+```
+
+Run spell checking:
+
+```python
+from transformers import AutoModel
+
+model_id = "LiquidAI/LFM2.5-Encoder-350-Spellchecker"
+
+model = AutoModel.from_pretrained(
+    model_id,
+    trust_remote_code=True,
+).float().eval()
+
+print(model.correct(["She go to school every day ."]))
+# ['She goes to school every day .']
+```
+
+`correct()` accepts a string or a list; tune precision with `min_error_prob` (higher → fewer edits) and
+`max_iter` (refinement passes). Input should be whitespace-tokenized (punctuation separated by spaces),
+matching the training data.
+
+## Evaluation
+
+Fixed inference setting: `max_iter=4`, precision knobs off. Headline [ERRANT](https://github.com/chrisjbryant/errant) F0.5:
+
+**MASTER composite (selection metric): 64.24**
+
+| Benchmark | Precision | Recall | F0.5 |
+|---|--:|--:|--:|
+| LOCNESS native (ERRANT) | 53.77 | 34.53 | 48.38 |
+| BEA-dev (ERRANT) | 56.48 | 28.96 | 47.46 |
+| CoNLL-14 (ERRANT) | 67.54 | 18.91 | 44.59 |
+| FCE-test (ERRANT) | 57.31 | 32.63 | 49.78 |
+| Robustness (ERRANT) | 91.96 | 87.98 | 91.14 |
+| Multilingual dev (F0.5) | — | — | — |
+
+## Examples
+
+| Input | Correction |
+|---|---|
+| `She go to school every day .` | `She goes to school every day .` |
+| `I has went to the stor yesterday .` | `I went to the store yesterday .` |
+| `Their are many reason to study hard .` | `There are many reasons to study hard .` |
+| `He don&#x27;t like coffee but he like tea .` | `He does n&#x27;t like coffee , but he likes tea .` |
+
+## 📬 Contact
+
+- Got questions or want to connect? [Join our Discord community](https://discord.com/invite/liquid-ai)
+- If you are interested in custom solutions with edge deployment, please contact [our sales team](https://www.liquid.ai/contact).
+
+## Citation
+
+```bibtex
+@article{liquidAI2026Encoders,
+  author = {Liquid AI},
+  title = {LFM2.5-Encoders: Fast at Long Context, Even on CPU},
+  journal = {Liquid AI Blog},
+  year = {2026},
+  note = {www.liquid.ai/blog/lfm2-5-encoders},
+}
+```

config.json

@@ -0,0 +1,21 @@
+{
+  "architectures": [
+    "GecTaggerForGEC"
+  ],
+  "model_type": "gec_tagger",
+  "auto_map": {
+    "AutoConfig": "modeling_gectagger.GecTaggerConfig",
+    "AutoModel": "modeling_gectagger.GecTaggerForGEC"
+  },
+  "encoder_name": "LiquidAI/LFM2.5-Encoder-350M",
+  "num_tags": 128802,
+  "hidden_size": 1024,
+  "tie_replace": true,
+  "multi_head": false,
+  "aux_loss_weight": 0.5,
+  "use_swap": false,
+  "qat_applied": false,
+  "qat_group_size": 32,
+  "dropout": 0.1,
+  "torch_dtype": "float16"
+}

examples.json

@@ -0,0 +1,18 @@
+[
+  {
+    "source": "She go to school every day .",
+    "corrected": "She goes to school every day ."
+  },
+  {
+    "source": "I has went to the stor yesterday .",
+    "corrected": "I went to the store yesterday ."
+  },
+  {
+    "source": "Their are many reason to study hard .",
+    "corrected": "There are many reasons to study hard ."
+  },
+  {
+    "source": "He don't like coffee but he like tea .",
+    "corrected": "He does n't like coffee , but he likes tea ."
+  }
+]

model.safetensors

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

modeling_gectagger.py

@@ -0,0 +1,381 @@
+"""Self-contained `transformers` modeling code for the LFM2.5 subword GEC tagger.
+
+This file ships INSIDE the Hugging Face model repo and is loaded via `trust_remote_code=True`. It must
+NOT import the `spellchecker` package (end users won't have it) — the architecture, the algorithmic
+subword tag space, and the iterative decode loop are all inlined here so the published model is usable
+with nothing but `transformers`:
+
+    from transformers import AutoModel
+    model = AutoModel.from_pretrained("LiquidAI/LFM2.5-Spellchecker-350M", trust_remote_code=True)
+    print(model.correct(["She go to school every day ."]))
+    # -> ["She goes to school every day ."]
+
+The tagger is a GECToR-style two-head model on a bidirectional MLM encoder. Tags are predicted per BPE
+piece; the label space is algorithmic (no vocab file):
+
+    0            = $KEEP                  leave this piece
+    1            = $DELETE                drop this piece
+    2            = $SWAP                  (only when use_swap) swap this piece with the next one
+    base..base+V = $REPLACE_<piece_id>    replace this piece with BPE piece <piece_id>
+    base+V..     = $APPEND_<piece_id>     keep this piece, insert BPE piece <piece_id> after it
+    base = 3 if use_swap else 2 ;  num_labels = base + 2*V ;  V = tokenizer vocab size
+
+Multi-piece / multi-word corrections emerge over the iterative passes (`correct` re-runs the tagger
+until the text stops changing or `max_iter` is hit). The sentence-initial anchor is the tokenizer BOS,
+prepended to every sequence; an $APPEND on it inserts at sentence start.
+"""
+from __future__ import annotations
+
+from typing import List
+
+import torch
+import torch.nn as nn
+from transformers import AutoConfig, AutoModelForMaskedLM, PretrainedConfig, PreTrainedModel
+
+# The self-contained reranker companion ships in the SAME repo (export_hub.py copies it next to this
+# file). transformers' trust_remote_code resolver scans the source for a relative import and ALSO copies
+# that sibling into the dynamic-module cache when the repo is loaded by id — without it the companion is
+# never materialised and the lazy load below would ModuleNotFoundError. The import FORM matters: the
+# resolver (dynamic_module_utils.get_relative_imports) only matches `from .<name> import ...` or
+# `import .<name>` — `from . import <name>` is NOT matched. So we import a sentinel from the companion
+# (which forces it into sys.modules) and grab the module object via sys.modules. Best effort: a model
+# with no reranker bundled (older export) still loads tagger-only.
+try:
+    from .reranker_gectagger import rerank as _rerank_fn       # noqa: F401  (resolver hint)
+    import sys as _sys
+    _reranker_mod = _sys.modules[__name__.rsplit(".", 1)[0] + ".reranker_gectagger"] \
+        if "." in __name__ else _sys.modules["reranker_gectagger"]
+except Exception:                                              # standalone / no companion -> tagger-only
+    _reranker_mod = None
+
+# --------------------------------------------------------------------------- tag space (algorithmic)
+
+KEEP_ID, DELETE_ID, SWAP_ID = 0, 1, 2
+INCORRECT = 1                 # detection-head class id gated by min_error_prob
+REPLACE, APPEND, SWAP = "$REPLACE_", "$APPEND_", "$SWAP"
+
+
+def _rep_base(use_swap: bool) -> int:
+    return 3 if use_swap else 2
+
+
+def id_to_tag(idx: int, vocab_size: int, use_swap: bool = False) -> str:
+    if idx == KEEP_ID:
+        return "$KEEP"
+    if idx == DELETE_ID:
+        return "$DELETE"
+    if use_swap and idx == SWAP_ID:
+        return SWAP
+    base = _rep_base(use_swap)
+    if idx < base + vocab_size:
+        return f"{REPLACE}{idx - base}"
+    return f"{APPEND}{idx - base - vocab_size}"
+
+
+def apply_tags(pieces: List[int], tags: List[str]) -> List[int]:
+    """Apply per-piece tags, returning the new piece-id list. pieces[0] is the BOS anchor and is never
+    emitted (an $APPEND on it inserts at sentence start). $SWAP emits the next piece then this one and
+    consumes both; it never fires on the BOS anchor."""
+    out: List[int] = []
+    i, n = 0, len(pieces)
+    while i < n:
+        p, t = pieces[i], tags[i]
+        is_start = i == 0
+        if t == SWAP and not is_start and i + 1 < n:
+            out.append(pieces[i + 1]); out.append(p); i += 2; continue
+        if t == "$KEEP" or t == SWAP:                  # SWAP with no valid neighbour -> safe keep
+            if not is_start:
+                out.append(p)
+        elif t == "$DELETE":
+            pass
+        elif t.startswith(REPLACE):
+            out.append(int(t[len(REPLACE):]))
+        elif t.startswith(APPEND):
+            if not is_start:
+                out.append(p)
+            out.append(int(t[len(APPEND):]))
+        else:                                          # unknown -> safe keep
+            if not is_start:
+                out.append(p)
+        i += 1
+    return out
+
+
+# --------------------------------------------------------------------------- config
+
+class GecTaggerConfig(PretrainedConfig):
+    model_type = "gec_tagger"
+
+    # NB: the field is `num_tags`, NOT `num_labels` — `num_labels` is a reserved PretrainedConfig
+    # property that auto-builds an id2label dict (here that would be 128802 entries) and breaks loading.
+    def __init__(self, encoder_name: str = "LiquidAI/mlm_phase2_bidir2_step140800", num_tags: int = 128802,
+                 hidden_size: int = 1024, tie_replace: bool = True, multi_head: bool = False,
+                 aux_loss_weight: float = 0.5, use_swap: bool = False, qat_applied: bool = False,
+                 qat_group_size: int = 32, dropout: float = 0.1, **kwargs):
+        self.encoder_name = encoder_name
+        self.num_tags = num_tags
+        self.hidden_size = hidden_size
+        self.tie_replace = tie_replace
+        self.multi_head = multi_head
+        self.aux_loss_weight = aux_loss_weight
+        self.use_swap = use_swap
+        self.qat_applied = qat_applied
+        self.qat_group_size = qat_group_size
+        self.dropout = dropout
+        super().__init__(**kwargs)
+
+
+# --------------------------------------------------------------------------- model
+
+def _last_hidden(backbone, input_ids, attention_mask) -> torch.Tensor:
+    out = backbone(input_ids=input_ids, attention_mask=attention_mask)
+    hs = getattr(out, "last_hidden_state", None)
+    if hs is None and getattr(out, "hidden_states", None) is not None:
+        hs = out.hidden_states[-1]
+    if hs is None:
+        hs = out[0]
+    return hs
+
+
+def _build_backbone(encoder_name: str):
+    """Build the bidirectional-LFM2 trunk shared across the whole encoder family (embedding / ColBERT /
+    encoder-MLM / token-classification / this tagger). Weights come from THIS repo's safetensors, so the
+    trunk is always built from config — no second encoder download.
+
+    Prefers the in-library ``transformers.Lfm2BidirectionalModel`` once the bidirectional-LFM2 family PR
+    lands: it is version-stable (no ``trust_remote_code`` for the trunk) and numerically identical to the
+    encoder repo's remote-code MLM base (verified 0.0 CPU / <1e-5 GPU by the family integration), so the
+    trained state_dict still loads 1:1 under ``encoder.*``. Until the class is exposed by ``transformers``
+    this transparently falls back to the encoder repo's own remote-code MLM class with the head stripped —
+    byte-identical to the original behaviour.
+    """
+    import transformers
+    native = getattr(transformers, "Lfm2BidirectionalModel", None)
+    if native is not None:                                    # native foundation (post family-PR)
+        cfg = AutoConfig.from_pretrained(encoder_name)        # model_type resolves natively, no remote code
+        try:
+            return native._from_config(cfg)
+        except AttributeError:
+            return native(cfg)
+    enc_cfg = AutoConfig.from_pretrained(encoder_name, trust_remote_code=True)   # fallback: encoder remote code
+    return AutoModelForMaskedLM.from_config(enc_cfg, trust_remote_code=True).base_model
+
+
+class GecTaggerForGEC(PreTrainedModel):
+    """GECToR two-head tagger. Submodule names match the training-time `spellchecker.model.GecTagger`
+    so the trained state_dict loads 1:1. With `tie_replace` the $REPLACE/$APPEND blocks are tied to the
+    encoder input embeddings (logit = proj(h) · embedding_i) rather than a free Linear(hidden, 2+2V)."""
+
+    config_class = GecTaggerConfig
+    base_model_prefix = "encoder"
+
+    def __init__(self, config: GecTaggerConfig):
+        super().__init__(config)
+        self._base = _rep_base(config.use_swap)
+        # Bidirectional-LFM2 trunk, shared with the rest of the encoder family. Weights come from this
+        # repo's safetensors (built from config, no second encoder download). Rides the in-library
+        # Lfm2BidirectionalModel once the family PR lands; falls back to the encoder's remote code today.
+        self.encoder = _build_backbone(config.encoder_name)
+        if config.qat_applied:
+            # dynamic import (not a top-level `from torchao...`): transformers statically scans this file
+            # for import lines and would otherwise REQUIRE torchao even for non-QAT models that never hit
+            # this branch. importlib keeps the dependency truly optional.
+            import importlib
+            qat = importlib.import_module("torchao.quantization.qat")
+            self.encoder = qat.Int4WeightOnlyQATQuantizer(groupsize=config.qat_group_size).prepare(self.encoder)
+        hidden = config.hidden_size
+        self.dropout = nn.Dropout(config.dropout)
+        self.detect_head = nn.Linear(hidden, 2)
+        if config.multi_head:
+            self.del_head = nn.Linear(hidden, 2)
+            self.ins_head = nn.Linear(hidden, 2)
+            self.sub_head = nn.Linear(hidden, 2)
+        if config.tie_replace:
+            V = (config.num_tags - self._base) // 2
+            assert self._base + 2 * V == config.num_tags, "tie_replace requires num_tags=base+2V"
+            self.vocab_size = V
+            self.base_head = nn.Linear(hidden, self._base)
+            self.replace_proj = nn.Linear(hidden, hidden)
+            self.append_proj = nn.Linear(hidden, hidden)
+            self.replace_bias = nn.Parameter(torch.zeros(V))
+            self.append_bias = nn.Parameter(torch.zeros(V))
+        else:
+            self.vocab_size = (config.num_tags - self._base) // 2
+            self.label_head = nn.Linear(hidden, config.num_tags)
+        self._tok = None                                # lazily-built tokenizer for .correct()
+        self._scorer = None                             # lazily-loaded reranker (reranker/ subfolder)
+        self._rerank_op = None                          # cached (keep_confidence, tau) operating point
+        self.post_init()                                # transformers 5.x: registers tied-weight keys etc.
+
+    def _label_logits(self, hidden):
+        if not self.config.tie_replace:
+            return self.label_head(hidden)
+        E = self.encoder.get_input_embeddings().weight[:self.vocab_size]      # [V, hidden] tied
+        base = self.base_head(hidden)
+        rep = self.replace_proj(hidden) @ E.t() + self.replace_bias
+        app = self.append_proj(hidden) @ E.t() + self.append_bias
+        return torch.cat([base, rep, app], dim=-1)
+
+    def forward(self, input_ids, attention_mask=None, **kwargs):
+        if attention_mask is None:
+            attention_mask = torch.ones_like(input_ids)
+        hidden = self.dropout(_last_hidden(self.encoder, input_ids, attention_mask))
+        out = {"label_logits": self._label_logits(hidden), "detect_logits": self.detect_head(hidden)}
+        if self.config.multi_head:
+            out["del_logits"] = self.del_head(hidden)
+            out["ins_logits"] = self.ins_head(hidden)
+            out["sub_logits"] = self.sub_head(hidden)
+        return out
+
+    # ---- inference ----------------------------------------------------------
+    def _tokenizer(self, tokenizer=None):
+        if tokenizer is not None:
+            return tokenizer
+        if self._tok is None:
+            from transformers import AutoTokenizer
+            # tokenizer files are saved into this repo, so name_or_path resolves locally; fall back to encoder
+            src = self.name_or_path or self.config.encoder_name
+            try:
+                self._tok = AutoTokenizer.from_pretrained(src, trust_remote_code=True)
+            except Exception:
+                self._tok = AutoTokenizer.from_pretrained(self.config.encoder_name, trust_remote_code=True)
+        return self._tok
+
+    @torch.no_grad()
+    def _step(self, seqs: List[List[int]], pad_id: int, batch_size: int, keep_confidence: float,
+              min_error_prob: float) -> List[List[int]]:
+        V, use_swap = self.vocab_size, self.config.use_swap
+        device = self.device
+        new_seqs: List[List[int]] = []
+        for i in range(0, len(seqs), batch_size):
+            chunk = seqs[i:i + batch_size]
+            maxlen = max(len(s) for s in chunk)
+            ids = torch.full((len(chunk), maxlen), pad_id, dtype=torch.long)
+            mask = torch.zeros((len(chunk), maxlen), dtype=torch.long)
+            for b, s in enumerate(chunk):
+                ids[b, :len(s)] = torch.tensor(s)
+                mask[b, :len(s)] = 1
+            res = self(ids.to(device), mask.to(device))
+            label_logits = res["label_logits"]
+            label_logits[..., KEEP_ID] += keep_confidence
+            best = label_logits.argmax(-1)
+            err_prob = res["detect_logits"].softmax(-1)[..., INCORRECT]
+            for b, s in enumerate(chunk):
+                tags = []
+                for pos in range(len(s)):
+                    lid = int(best[b, pos])
+                    ok = lid != KEEP_ID and float(err_prob[b, pos]) >= min_error_prob
+                    tags.append(id_to_tag(lid, V, use_swap) if ok else "$KEEP")
+                new_seqs.append(apply_tags(s, tags))
+        return new_seqs
+
+    def _tag_correct(self, texts, tok, max_iter, max_len, batch_size, keep_confidence,
+                     min_error_prob) -> List[str]:
+        """Tagger-only iterative decode (the original `.correct()` body). Returns a corrected string
+        per input. `keep_confidence` < 0 over-generates edits (used by the reranker)."""
+        bos_id = tok.bos_token_id if tok.bos_token_id is not None else (tok.cls_token_id or 0)
+        pad_id = tok.pad_token_id if tok.pad_token_id is not None else 0
+        cur = [[bos_id] + tok.encode(t, add_special_tokens=False)[:max_len - 1] for t in texts]
+        active = list(range(len(cur)))
+        for _ in range(max_iter):
+            if not active:
+                break
+            updated = self._step([cur[i] for i in active], pad_id, batch_size,
+                                  keep_confidence, min_error_prob)
+            still = []
+            for idx, new in zip(active, updated):
+                new = [bos_id] + new
+                if new != cur[idx]:
+                    cur[idx] = new
+                    still.append(idx)
+            active = still
+        return [tok.decode(s[1:], skip_special_tokens=True).strip() for s in cur]
+
+    # ---- reranker (lazy, from this repo's reranker/ subfolder) ---------------
+    def _reranker(self):
+        """Lazily load (scorer, keep_confidence, tau) from the SAME repo's `reranker/` subfolder.
+        Returns None if no reranker is bundled (then `.correct()` falls back to tagger-only). The
+        scorer + operating point ship next to the model weights; nothing is fetched from elsewhere."""
+        if self._scorer is not None:
+            return self._scorer, self._rerank_op
+        import json
+        import os
+        rr = _reranker_mod
+        if rr is None:                                    # companion not present -> tagger-only
+            print("[gectagger] reranker companion module not bundled; using tagger-only .correct()")
+            self._scorer, self._rerank_op = False, None
+            return False, None
+        # locate the reranker/ subfolder: local export dir, or fetch from the hub repo by id
+        base = self.name_or_path or ""
+        scorer_dir = os.path.join(base, "reranker") if base else ""
+        if not (scorer_dir and os.path.isfile(os.path.join(scorer_dir, "scorer_config.json"))):
+            try:                                          # not a local dir -> resolve the hub repo
+                from huggingface_hub import snapshot_download
+                tok_env = os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN")
+                local = snapshot_download(repo_id=base, allow_patterns=["reranker/*"], token=tok_env)
+                scorer_dir = os.path.join(local, "reranker")
+            except Exception as e:
+                print(f"[gectagger] reranker not available ({e}); using tagger-only .correct()")
+                self._scorer, self._rerank_op = False, None
+                return False, None
+        if not os.path.isfile(os.path.join(scorer_dir, "scorer_config.json")):
+            print(f"[gectagger] no reranker/ in {base}; using tagger-only .correct()")
+            self._scorer, self._rerank_op = False, None
+            return False, None
+        kc, tau = -0.25, 0.4                              # shipped default operating point
+        op_path = os.path.join(scorer_dir, "operating_point.json")
+        if os.path.isfile(op_path):
+            op = json.load(open(op_path))
+            kc = float(op.get("keep_confidence", kc))
+            tau = float(op.get("tau", tau))
+        # match the tagger's ACTUAL weight dtype (read from a real parameter, not self.dtype which is
+        # unreliable when the from_config encoder carries fp32 buffers) so the shared-shape matmuls in
+        # the scorer don't hit a Float-vs-Half mismatch (the Space casts the whole model to fp16).
+        try:
+            tagger_dtype = next(self.base_head.parameters()).dtype
+        except Exception:
+            tagger_dtype = self.dtype
+        scorer = rr.EditScorer.load(scorer_dir).to(self.device).to(tagger_dtype)
+        scorer.eval()
+        self._scorer, self._rerank_op = scorer, (kc, tau)
+        print(f"[gectagger] reranker loaded from {scorer_dir} (mode={scorer.mode}, "
+              f"type_feature={scorer.type_feature}); operating point keep_confidence={kc} tau={tau}")
+        return self._scorer, self._rerank_op
+
+    @torch.no_grad()
+    def correct(self, texts, tokenizer=None, max_iter: int = 3, max_len: int = 128, batch_size: int = 64,
+                keep_confidence: float = 0.0, min_error_prob: float = 0.0, rerank: bool = True) -> List[str]:
+        """Correct a list of (whitespace-tokenized) sentences. Iterates tag->apply until the text stops
+        changing or `max_iter` is reached. `min_error_prob` / `keep_confidence` are the GECToR precision
+        knobs (higher => fewer edits).
+
+        rerank=True (default): run the FULL system — let the tagger over-generate at the bundled
+        operating point's `keep_confidence`, then a per-edit scorer (loaded once from this repo's
+        `reranker/` subfolder) keeps only edits with P(correct) >= tau and re-applies them to the
+        source. This is the published MASTER-composite operating point. If no reranker is bundled, it
+        transparently falls back to tagger-only. rerank=False: exact tagger-only behaviour, using the
+        `keep_confidence` / `min_error_prob` passed in."""
+        single = isinstance(texts, str)
+        if single:
+            texts = [texts]
+        tok = self._tokenizer(tokenizer)
+        self.eval()
+
+        if not rerank:
+            out = self._tag_correct(texts, tok, max_iter, max_len, batch_size,
+                                    keep_confidence, min_error_prob)
+            return out[0] if single else out
+
+        scorer, op = self._reranker()
+        if not scorer:                                    # no reranker bundled -> tagger-only fallback
+            out = self._tag_correct(texts, tok, max_iter, max_len, batch_size,
+                                    keep_confidence, min_error_prob)
+            return out[0] if single else out
+        kc, tau = op
+        # over-generate with the tagger at the scorer's training operating point (negative kc), then
+        # filter per-edit. min_error_prob stays at 0 here so the scorer — not the detection gate — is
+        # the precision lever (this is the configuration the published MASTER was measured at).
+        hyps = self._tag_correct(texts, tok, max_iter, max_len, batch_size, kc, 0.0)
+        out = _reranker_mod.rerank(scorer, tok, list(texts), hyps, tau, self.device,
+                                   batch_size=batch_size)
+        return out[0] if single else out

requirements.txt

@@ -0,0 +1,7 @@
+transformers>=4.44
+torch>=2.1
+safetensors
+huggingface_hub>=0.26
+errant==3.0.2
+spacy==3.8.14
+https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.8.0/en_core_web_sm-3.8.0-py3-none-any.whl

reranker/operating_point.json

@@ -0,0 +1,370 @@
+{
+  "keep_confidence": 0.0,
+  "tau": 0.3,
+  "MASTER": 0.6587,
+  "control_master": 0.631,
+  "scorer_run": "runs/reranker/en_v2_rr/best",
+  "report": "reranker_en_v2_rr.json",
+  "grid": [
+    {
+      "keep_confidence": -0.25,
+      "tau": 0.2,
+      "MASTER": 0.6452,
+      "MASTER_V2": 0.6864,
+      "precision": 0.6054,
+      "recall": 0.3411,
+      "f0.5": 0.5242,
+      "group_means": {
+        "native": 0.3526,
+        "learner": 0.4991,
+        "robustness": 0.94,
+        "precision": 0.9355,
+        "typo": 0.7538
+      },
+      "fp_clean": 0.9355,
+      "per_eval": {
+        "ndev_native": 0.495,
+        "cweb_g": 0.3111,
+        "cweb_s": 0.2518,
+        "bea_dev": 0.4989,
+        "conll14": 0.4799,
+        "fce_test": 0.5186,
+        "robustness": 0.94,
+        "fp_clean": 0.9355,
+        "github_typo_test": 0.6545,
+        "garble": 0.8476,
+        "native_conf": 0.7593
+      }
+    },
+    {
+      "keep_confidence": -0.25,
+      "tau": 0.25,
+      "MASTER": 0.6482,
+      "MASTER_V2": 0.6901,
+      "precision": 0.6206,
+      "recall": 0.3378,
+      "f0.5": 0.5316,
+      "group_means": {
+        "native": 0.3577,
+        "learner": 0.5054,
+        "robustness": 0.9388,
+        "precision": 0.9355,
+        "typo": 0.7621
+      },
+      "fp_clean": 0.9355,
+      "per_eval": {
+        "ndev_native": 0.5034,
+        "cweb_g": 0.3147,
+        "cweb_s": 0.2551,
+        "bea_dev": 0.5072,
+        "conll14": 0.4817,
+        "fce_test": 0.5274,
+        "robustness": 0.9388,
+        "fp_clean": 0.9355,
+        "github_typo_test": 0.662,
+        "garble": 0.8562,
+        "native_conf": 0.7681
+      }
+    },
+    {
+      "keep_confidence": -0.25,
+      "tau": 0.3,
+      "MASTER": 0.6502,
+      "MASTER_V2": 0.6932,
+      "precision": 0.6367,
+      "recall": 0.3313,
+      "f0.5": 0.5376,
+      "group_means": {
+        "native": 0.3621,
+        "learner": 0.5099,
+        "robustness": 0.9362,
+        "precision": 0.9355,
+        "typo": 0.7716
+      },
+      "fp_clean": 0.9355,
+      "per_eval": {
+        "ndev_native": 0.5111,
+        "cweb_g": 0.3163,
+        "cweb_s": 0.259,
+        "bea_dev": 0.5099,
+        "conll14": 0.4821,
+        "fce_test": 0.5376,
+        "robustness": 0.9362,
+        "fp_clean": 0.9355,
+        "github_typo_test": 0.6705,
+        "garble": 0.8671,
+        "native_conf": 0.7771
+      }
+    },
+    {
+      "keep_confidence": -0.25,
+      "tau": 0.4,
+      "MASTER": 0.6518,
+      "MASTER_V2": 0.6979,
+      "precision": 0.6765,
+      "recall": 0.3072,
+      "f0.5": 0.5454,
+      "group_means": {
+        "native": 0.3653,
+        "learner": 0.511,
+        "robustness": 0.9058,
+        "precision": 0.9677,
+        "typo": 0.7881
+      },
+      "fp_clean": 0.9677,
+      "per_eval": {
+        "ndev_native": 0.5178,
+        "cweb_g": 0.3143,
+        "cweb_s": 0.2639,
+        "bea_dev": 0.5086,
+        "conll14": 0.4734,
+        "fce_test": 0.5511,
+        "robustness": 0.9058,
+        "fp_clean": 0.9677,
+        "github_typo_test": 0.6879,
+        "garble": 0.8917,
+        "native_conf": 0.7846
+      }
+    },
+    {
+      "keep_confidence": -0.5,
+      "tau": 0.2,
+      "MASTER": 0.6426,
+      "MASTER_V2": 0.6785,
+      "precision": 0.5737,
+      "recall": 0.3623,
+      "f0.5": 0.5137,
+      "group_means": {
+        "native": 0.3514,
+        "learner": 0.4967,
+        "robustness": 0.9325,
+        "precision": 0.9355,
+        "typo": 0.7247
+      },
+      "fp_clean": 0.9355,
+      "per_eval": {
+        "ndev_native": 0.4931,
+        "cweb_g": 0.3102,
+        "cweb_s": 0.251,
+        "bea_dev": 0.4974,
+        "conll14": 0.482,
+        "fce_test": 0.5106,
+        "robustness": 0.9325,
+        "fp_clean": 0.9355,
+        "github_typo_test": 0.6203,
+        "garble": 0.8356,
+        "native_conf": 0.7182
+      }
+    },
+    {
+      "keep_confidence": -0.5,
+      "tau": 0.25,
+      "MASTER": 0.6461,
+      "MASTER_V2": 0.6831,
+      "precision": 0.5898,
+      "recall": 0.358,
+      "f0.5": 0.5222,
+      "group_means": {
+        "native": 0.357,
+        "learner": 0.5044,
+        "robustness": 0.9312,
+        "precision": 0.9355,
+        "typo": 0.7364
+      },
+      "fp_clean": 0.9355,
+      "per_eval": {
+        "ndev_native": 0.5018,
+        "cweb_g": 0.315,
+        "cweb_s": 0.2543,
+        "bea_dev": 0.5064,
+        "conll14": 0.4866,
+        "fce_test": 0.5203,
+        "robustness": 0.9312,
+        "fp_clean": 0.9355,
+        "github_typo_test": 0.6281,
+        "garble": 0.847,
+        "native_conf": 0.7341
+      }
+    },
+    {
+      "keep_confidence": -0.5,
+      "tau": 0.3,
+      "MASTER": 0.6491,
+      "MASTER_V2": 0.6881,
+      "precision": 0.6076,
+      "recall": 0.3503,
+      "f0.5": 0.5298,
+      "group_means": {
+        "native": 0.3632,
+        "learner": 0.5108,
+        "robustness": 0.9283,
+        "precision": 0.9355,
+        "typo": 0.7517
+      },
+      "fp_clean": 0.9355,
+      "per_eval": {
+        "ndev_native": 0.5131,
+        "cweb_g": 0.3178,
+        "cweb_s": 0.2587,
+        "bea_dev": 0.5118,
+        "conll14": 0.49,
+        "fce_test": 0.5305,
+        "robustness": 0.9283,
+        "fp_clean": 0.9355,
+        "github_typo_test": 0.6373,
+        "garble": 0.8585,
+        "native_conf": 0.7593
+      }
+    },
+    {
+      "keep_confidence": -0.5,
+      "tau": 0.4,
+      "MASTER": 0.6527,
+      "MASTER_V2": 0.6949,
+      "precision": 0.6515,
+      "recall": 0.3212,
+      "f0.5": 0.5404,
+      "group_means": {
+        "native": 0.367,
+        "learner": 0.5145,
+        "robustness": 0.9031,
+        "precision": 0.9677,
+        "typo": 0.7712
+      },
+      "fp_clean": 0.9677,
+      "per_eval": {
+        "ndev_native": 0.5213,
+        "cweb_g": 0.3199,
+        "cweb_s": 0.2597,
+        "bea_dev": 0.5108,
+        "conll14": 0.4838,
+        "fce_test": 0.5489,
+        "robustness": 0.9031,
+        "fp_clean": 0.9677,
+        "github_typo_test": 0.6621,
+        "garble": 0.8857,
+        "native_conf": 0.7658
+      }
+    },
+    {
+      "keep_confidence": 0.0,
+      "tau": 0.2,
+      "MASTER": 0.6552,
+      "MASTER_V2": 0.7006,
+      "precision": 0.6337,
+      "recall": 0.3147,
+      "f0.5": 0.5269,
+      "group_means": {
+        "native": 0.3549,
+        "learner": 0.489,
+        "robustness": 0.9324,
+        "precision": 1.0,
+        "typo": 0.7714
+      },
+      "fp_clean": 1.0,
+      "per_eval": {
+        "ndev_native": 0.5,
+        "cweb_g": 0.3046,
+        "cweb_s": 0.2601,
+        "bea_dev": 0.4921,
+        "conll14": 0.4546,
+        "fce_test": 0.5202,
+        "robustness": 0.9324,
+        "fp_clean": 1.0,
+        "github_typo_test": 0.6787,
+        "garble": 0.8529,
+        "native_conf": 0.7826
+      }
+    },
+    {
+      "keep_confidence": 0.0,
+      "tau": 0.25,
+      "MASTER": 0.6577,
+      "MASTER_V2": 0.7033,
+      "precision": 0.6475,
+      "recall": 0.3125,
+      "f0.5": 0.5332,
+      "group_means": {
+        "native": 0.3596,
+        "learner": 0.4941,
+        "robustness": 0.9311,
+        "precision": 1.0,
+        "typo": 0.7763
+      },
+      "fp_clean": 1.0,
+      "per_eval": {
+        "ndev_native": 0.5062,
+        "cweb_g": 0.3095,
+        "cweb_s": 0.2631,
+        "bea_dev": 0.4984,
+        "conll14": 0.4558,
+        "fce_test": 0.5282,
+        "robustness": 0.9311,
+        "fp_clean": 1.0,
+        "github_typo_test": 0.6851,
+        "garble": 0.8611,
+        "native_conf": 0.7826
+      }
+    },
+    {
+      "keep_confidence": 0.0,
+      "tau": 0.3,
+      "MASTER": 0.6587,
+      "MASTER_V2": 0.7053,
+      "precision": 0.6636,
+      "recall": 0.3076,
+      "f0.5": 0.5389,
+      "group_means": {
+        "native": 0.3622,
+        "learner": 0.499,
+        "robustness": 0.9255,
+        "precision": 1.0,
+        "typo": 0.7854
+      },
+      "fp_clean": 1.0,
+      "per_eval": {
+        "ndev_native": 0.5124,
+        "cweb_g": 0.309,
+        "cweb_s": 0.2653,
+        "bea_dev": 0.501,
+        "conll14": 0.4575,
+        "fce_test": 0.5385,
+        "robustness": 0.9255,
+        "fp_clean": 1.0,
+        "github_typo_test": 0.6933,
+        "garble": 0.8711,
+        "native_conf": 0.7918
+      }
+    },
+    {
+      "keep_confidence": 0.0,
+      "tau": 0.4,
+      "MASTER": 0.6545,
+      "MASTER_V2": 0.7045,
+      "precision": 0.7013,
+      "recall": 0.2881,
+      "f0.5": 0.545,
+      "group_means": {
+        "native": 0.3656,
+        "learner": 0.4982,
+        "robustness": 0.9024,
+        "precision": 1.0,
+        "typo": 0.8004
+      },
+      "fp_clean": 1.0,
+      "per_eval": {
+        "ndev_native": 0.5208,
+        "cweb_g": 0.3057,
+        "cweb_s": 0.2702,
+        "bea_dev": 0.4994,
+        "conll14": 0.4478,
+        "fce_test": 0.5475,
+        "robustness": 0.9024,
+        "fp_clean": 1.0,
+        "github_typo_test": 0.7092,
+        "garble": 0.892,
+        "native_conf": 0.8
+      }
+    }
+  ]
+}

reranker/pytorch_model.bin

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

reranker/scorer_config.json

@@ -0,0 +1,6 @@
+{
+  "encoder_name": "LiquidAI/LFM2.5-Encoder-350M",
+  "hidden_size": 1024,
+  "mode": "cross",
+  "type_feature": true
+}

reranker_gectagger.py

@@ -0,0 +1,466 @@
+"""Self-contained edit reranker that ships INSIDE the Hugging Face model repo alongside
+`modeling_gectagger.py` and is loaded via `trust_remote_code=True`. It must NOT import the
+`spellchecker` package (end users / the Space won't have it) and must NOT depend on `errant`/`spaCy`
+(the Space ships only transformers + safetensors). Everything the per-edit reranker needs — the
+EditScorer architecture, the candidate-input construction, a dependency-free word-level edit
+extractor, and the over-generate -> score -> filter -> re-apply logic — is inlined here.
+
+This is the inference twin of `spellchecker/reranker.py` (training/eval code). The scorer is a
+shared-backbone binary classifier (EditScorer-style, Sorokin 2022): the tagger over-generates edits at
+a negative `keep_confidence`, each proposed edit is scored P(correct), and only edits with P >= tau are
+kept and re-applied to the source. The shipped scorer is the `cross` variant with a per-ERRANT-type
+feature; its weights + operating point live in the SAME repo's `reranker/` subfolder, lazily loaded on
+first `.correct(..., rerank=True)`.
+
+FIDELITY NOTE — edit extraction. The scorer was trained and the published MASTER (0.6642) measured with
+ERRANT word-level alignment (`tokenise=False`) of source->hypothesis. ERRANT needs spaCy, which is not
+available at serve time, so this module extracts edits with a dependency-free `difflib` word diff and
+recovers ERRANT-style minimal edits by splitting aligned (replace) blocks token-by-token where the
+block is length-preserving — the common case ERRANT also splits. The candidate char-span construction
+and scorer input are otherwise byte-identical to the training path, so a candidate's score matches.
+`type_feature` types are coarse (M/U/R + a couple of cheap subtypes) rather than full ERRANT types; the
+type only feeds a hash bucket, so coarse types still calibrate per broad error class. See the local
+verification in the publish flow for the measured tagger-only vs reranked behaviour on the exported repo.
+"""
+from __future__ import annotations
+
+import difflib
+import json
+import os
+import zlib
+from collections import defaultdict
+from typing import Dict, List, Sequence, Tuple
+
+import torch
+import torch.nn as nn
+from transformers import AutoConfig, AutoModelForMaskedLM
+
+# --------------------------------------------------------------------------- encoder trunk
+
+def _backbone(name: str, pretrained: bool = False):
+    """(backbone_module, hidden_size). The shared bidirectional-LFM2 trunk (same as the tagger's).
+
+    Prefers the in-library ``transformers.Lfm2BidirectionalModel`` once the bidirectional-LFM2 family PR
+    lands — version-stable, no remote code for the trunk, numerically identical to the encoder repo's
+    remote-code MLM base (verified 0.0 CPU / <1e-5 GPU), so the scorer's state_dict still loads 1:1 under
+    ``encoder.*``. Until then it falls back to the encoder repo's remote-code MLM class with the head
+    stripped (the original behaviour). For inference inside the published repo we build from config
+    (pretrained=False) and load the scorer's own weights — no second encoder download."""
+    import transformers
+    native = getattr(transformers, "Lfm2BidirectionalModel", None)
+    if native is not None:                                    # native foundation (post family-PR)
+        config = AutoConfig.from_pretrained(name)             # model_type resolves natively, no remote code
+        hidden = getattr(config, "hidden_size", None) or getattr(config, "d_model", None) or 1024
+        if pretrained:
+            backbone = native.from_pretrained(name)
+        else:
+            try:
+                backbone = native._from_config(config)
+            except AttributeError:
+                backbone = native(config)
+        return backbone, hidden
+    config = AutoConfig.from_pretrained(name, trust_remote_code=True)   # fallback: encoder remote code
+    hidden = getattr(config, "hidden_size", None) or getattr(config, "d_model", None) or 1024
+    if pretrained:
+        mlm = AutoModelForMaskedLM.from_pretrained(name, trust_remote_code=True)
+    else:
+        mlm = AutoModelForMaskedLM.from_config(config, trust_remote_code=True)
+    return mlm.base_model, hidden
+
+
+def _last_hidden(backbone, input_ids, attention_mask) -> torch.Tensor:
+    out = backbone(input_ids=input_ids, attention_mask=attention_mask)
+    hs = getattr(out, "last_hidden_state", None)
+    if hs is None and getattr(out, "hidden_states", None) is not None:
+        hs = out.hidden_states[-1]
+    if hs is None:
+        hs = out[0]
+    return hs
+
+
+# --------------------------------------------------------------- candidate input construction
+# (byte-identical to spellchecker.reranker so a candidate's encoder input matches the trained scorer)
+
+def apply_edits(tokens: List[str], edits: List[Dict]) -> List[str]:
+    """Apply token-span edits to `tokens` (same semantics as spellchecker.edits.apply_edits)."""
+    out: List[str] = []
+    prev = 0
+    for e in sorted(edits, key=lambda e: (int(e["start"]), int(e["end"]))):
+        start, end = int(e["start"]), int(e["end"])
+        if start < prev:                       # overlapping: drop
+            continue
+        out.extend(tokens[prev:start])
+        repl = str(e["replacement"])
+        if repl:
+            out.extend(repl.split())
+        prev = end
+    out.extend(tokens[prev:])
+    return out
+
+
+def build_scorer_input(src_tokens: Sequence[str], edit: Dict) -> Tuple[str, int, int]:
+    a, b = int(edit["start"]), int(edit["end"])
+    rep = str(edit["replacement"]).split()
+    out = list(src_tokens[:a]) + rep + list(src_tokens[b:])
+    text = " ".join(out)
+    if rep:
+        c0 = len(" ".join(out[:a])) + (1 if a > 0 else 0)
+        c1 = c0 + len(" ".join(rep))
+    else:                                          # deletion: pool over flanking tokens
+        left, right = max(a - 1, 0), min(a + 1, len(out))
+        c0 = len(" ".join(out[:left])) + (1 if left > 0 else 0)
+        c1 = c0 + len(" ".join(out[left:right]))
+        if c1 <= c0:
+            c0, c1 = 0, max(len(text), 1)
+    return text, c0, c1
+
+
+def build_source_input(src_tokens: Sequence[str], edit: Dict) -> Tuple[str, int, int]:
+    a, b = int(edit["start"]), int(edit["end"])
+    text = " ".join(src_tokens)
+    if a < b:
+        c0 = len(" ".join(src_tokens[:a])) + (1 if a > 0 else 0)
+        c1 = c0 + len(" ".join(src_tokens[a:b]))
+    else:                                          # insertion: pool over the gap's neighbours
+        left, right = max(a - 1, 0), min(a + 1, len(src_tokens))
+        c0 = len(" ".join(src_tokens[:left])) + (1 if left > 0 else 0)
+        c1 = c0 + len(" ".join(src_tokens[left:right]))
+        if c1 <= c0:
+            c0, c1 = 0, max(len(text), 1)
+    return text, c0, c1
+
+
+def sep_token(tokenizer) -> str:
+    return tokenizer.sep_token or tokenizer.eos_token or "||"
+
+
+def build_cross_input(src_tokens: Sequence[str], edit: Dict, sep: str
+                      ) -> Tuple[str, int, int, int, int]:
+    s_text, s0, s1 = build_source_input(src_tokens, edit)
+    e_text, e0, e1 = build_scorer_input(src_tokens, edit)
+    text = f"{s_text} {sep} {e_text}"
+    off = len(s_text) + len(sep) + 2
+    return text, off + e0, off + e1, s0, s1
+
+
+def type_bucket(edit_type: str, buckets: int = 64) -> int:
+    return zlib.crc32(str(edit_type).encode()) % buckets
+
+
+def encode_candidates(tokenizer, items: List[Tuple[str, int, int]], max_len: int = 160):
+    texts = [t for t, _, _ in items]
+    enc = tokenizer(texts, return_tensors="pt", padding=True, truncation=True, max_length=max_len,
+                    return_offsets_mapping=True)
+    offsets = enc.pop("offset_mapping")
+    span = torch.zeros_like(enc["attention_mask"])
+    for i, (_, c0, c1) in enumerate(items):
+        for j, (o0, o1) in enumerate(offsets[i].tolist()):
+            if enc["attention_mask"][i, j] and o1 > o0 and o0 < c1 and o1 > c0:
+                span[i, j] = 1
+        if not span[i].any():
+            span[i] = enc["attention_mask"][i]
+    return enc["input_ids"], enc["attention_mask"], span
+
+
+def encode_cross(tokenizer, items: List[Tuple[str, int, int, int, int]], max_len: int = 320):
+    texts = [t for t, *_ in items]
+    enc = tokenizer(texts, return_tensors="pt", padding=True, truncation=True, max_length=max_len,
+                    return_offsets_mapping=True)
+    offsets = enc.pop("offset_mapping")
+    spans = [torch.zeros_like(enc["attention_mask"]) for _ in range(2)]
+    for i, (_, e0, e1, s0, s1) in enumerate(items):
+        for j, (o0, o1) in enumerate(offsets[i].tolist()):
+            if not enc["attention_mask"][i, j] or o1 <= o0:
+                continue
+            if o0 < e1 and o1 > e0:
+                spans[0][i, j] = 1
+            if o0 < s1 and o1 > s0:
+                spans[1][i, j] = 1
+        for s in spans:
+            if not s[i].any():
+                s[i] = enc["attention_mask"][i]
+    return enc["input_ids"], enc["attention_mask"], spans[0], spans[1]
+
+
+# --------------------------------------------------------------- dependency-free edit extraction
+
+_VOWELS = set("aeiouAEIOU")
+
+
+def _coarse_type(src_span: List[str], rep: List[str]) -> str:
+    """Coarse ERRANT-ish type for the per-type feature hash. Full ERRANT types need spaCy; the type
+    only feeds a 64-way hash bucket, so a broad class (M/U/R + a couple cheap subtypes) is enough to
+    let the head calibrate per error family. Mirrors the M/U/R coarse scheme of edits.align_generic."""
+    if not src_span:
+        return "M"                                   # missing -> insertion
+    if not rep:
+        return "U"                                   # unnecessary -> deletion
+    if len(src_span) == 1 and len(rep) == 1:
+        a, b = src_span[0], rep[0]
+        la, lb = a.lower(), b.lower()
+        if la == lb:
+            return "R:ORTH"                           # casing only
+        if not any(ch.isalnum() for ch in a) and not any(ch.isalnum() for ch in b):
+            return "R:PUNCT"
+        # cheap spelling cue: same first letter & similar length & shared letter multiset
+        if a and b and la[0] == lb[0] and abs(len(a) - len(b)) <= 2:
+            return "R:SPELL"
+    return "R:OTHER"
+
+
+def _char_sim(a: str, b: str) -> float:
+    """SequenceMatcher ratio on characters (cheap stand-in for ERRANT's lemma/char substitution cost)."""
+    if a == b:
+        return 1.0
+    return difflib.SequenceMatcher(None, a, b, autojunk=False).ratio()
+
+
+def _align_block(src: List[str], tgt: List[str], i0: int, sub_thresh: float = 0.30) -> List[Dict]:
+    """Levenshtein-align a difflib `replace` block at the TOKEN level (this is the core of what ERRANT
+    does before its linguistic merge): a token pairs with another as a SUBSTITUTION only when they are
+    char-similar enough (>= sub_thresh), otherwise the diff is resolved as a DELETE + INSERT at the
+    junction. Emits minimal per-position edits with absolute offsets (block starts at source index i0).
+    This recovers ERRANT's split of e.g. `than a` into R:`than` + M:`a`, which a single merged
+    candidate would not — the recall the scale fidelity check showed difflib was dropping."""
+    m, n = len(src), len(tgt)
+    INS, DEL = 1.0, 1.0                                  # unit cost for an unmatched token
+    # DP edit distance with substitution cost = 1 - char_sim (cheap matches preferred as subs)
+    cost = [[0.0] * (n + 1) for _ in range(m + 1)]
+    bt = [[None] * (n + 1) for _ in range(m + 1)]
+    for i in range(1, m + 1):
+        cost[i][0] = i * DEL; bt[i][0] = "d"
+    for j in range(1, n + 1):
+        cost[0][j] = j * INS; bt[0][j] = "i"
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            sub = cost[i - 1][j - 1] + (1.0 - _char_sim(src[i - 1], tgt[j - 1]))
+            dele = cost[i - 1][j] + DEL
+            ins = cost[i][j - 1] + INS
+            best = min(sub, dele, ins)
+            cost[i][j] = best
+            bt[i][j] = "s" if best == sub else ("d" if best == dele else "i")
+    # backtrace into aligned ops
+    ops = []
+    i, j = m, n
+    while i > 0 or j > 0:
+        step = bt[i][j]
+        if step == "s":
+            ops.append(("s", i - 1, j - 1)); i -= 1; j -= 1
+        elif step == "d":
+            ops.append(("d", i - 1, None)); i -= 1
+        else:
+            ops.append(("i", i, j - 1)); j -= 1                 # insert before source position i
+    ops.reverse()
+    edits: List[Dict] = []
+    for kind, si, tj in ops:
+        if kind == "s":
+            a, b = src[si], tgt[tj]
+            if a == b:
+                continue
+            # a poor "substitution" (char-dissimilar) is really a delete+insert at this junction
+            if _char_sim(a, b) < sub_thresh:
+                edits.append({"start": i0 + si, "end": i0 + si + 1, "replacement": "",
+                              "type": _coarse_type([a], [])})
+                edits.append({"start": i0 + si + 1, "end": i0 + si + 1, "replacement": b,
+                              "type": _coarse_type([], [b])})
+            else:
+                edits.append({"start": i0 + si, "end": i0 + si + 1, "replacement": b,
+                              "type": _coarse_type([a], [b])})
+        elif kind == "d":
+            edits.append({"start": i0 + si, "end": i0 + si + 1, "replacement": "",
+                          "type": _coarse_type([src[si]], [])})
+        else:  # insert before source index si
+            edits.append({"start": i0 + si, "end": i0 + si, "replacement": tgt[tj],
+                          "type": _coarse_type([], [tgt[tj]])})
+    return edits
+
+
+_ERRANT_ANNOTATOR = None
+_ERRANT_TRIED = False
+
+
+def _errant_edits(src: str, hyp: str):
+    """ERRANT word-level edits (tokenise=False) — the SAME alignment the scorer was trained and the
+    published MASTER measured on. Returns None if `errant` (and its spaCy model) is not installed, so
+    the caller falls back to the difflib extractor. ERRANT's linguistically-merged minimal edits are
+    the granularity the cross+type scorer expects; reproducing them keeps the published metric intact."""
+    global _ERRANT_ANNOTATOR, _ERRANT_TRIED
+    if _ERRANT_ANNOTATOR is None:
+        if _ERRANT_TRIED:
+            return None
+        _ERRANT_TRIED = True
+        try:
+            import errant
+            _ERRANT_ANNOTATOR = errant.load("en")
+        except Exception as e:
+            print(f"[gectagger] errant unavailable ({type(e).__name__}); reranker edit extraction "
+                  f"falls back to difflib (slightly lower recall than the ERRANT-measured operating "
+                  f"point). Install `errant` for the published behaviour.")
+            return None
+    ann = _ERRANT_ANNOTATOR
+    orig, cor = ann.parse(src, False), ann.parse(hyp, False)
+    out = []
+    for e in ann.annotate(orig, cor):
+        out.append({"start": int(e.o_start), "end": int(e.o_end),
+                    "replacement": e.c_str, "type": e.type})
+    return out
+
+
+def _difflib_edits(src: str, hyp: str) -> List[Dict]:
+    """Dependency-free fallback: difflib word diff, `replace` blocks resolved by a token-level
+    Levenshtein alignment (_align_block) into minimal sub/ins/del edits. Close to ERRANT but not exact
+    (no linguistic merge / typing); used only when errant is not importable."""
+    s, t = src.split(), hyp.split()
+    edits: List[Dict] = []
+    for op, i1, i2, j1, j2 in difflib.SequenceMatcher(None, s, t, autojunk=False).get_opcodes():
+        if op == "equal":
+            continue
+        if op == "delete":
+            for k in range(i1, i2):
+                edits.append({"start": k, "end": k + 1, "replacement": "",
+                              "type": _coarse_type([s[k]], [])})
+        elif op == "insert":
+            edits.append({"start": i1, "end": i1, "replacement": " ".join(t[j1:j2]),
+                          "type": _coarse_type([], t[j1:j2])})
+        else:
+            edits.extend(_align_block(s[i1:i2], t[j1:j2], i1))
+    return edits
+
+
+def extract_edits(src: str, hyp: str) -> List[Dict]:
+    """Word-level edits taking `src` -> `hyp` as token-span dicts {start,end,replacement,type} into
+    src.split(). Uses ERRANT (the alignment the scorer was trained / the MASTER was measured on) when
+    available, falling back to a self-contained difflib aligner otherwise."""
+    e = _errant_edits(src, hyp)
+    if e is not None:
+        return e
+    return _difflib_edits(src, hyp)
+
+
+# ------------------------------------------------------------------------------------ the scorer
+
+def _resolve_mode(cfg: Dict) -> str:
+    if "mode" in cfg:
+        return cfg["mode"]
+    return "pairwise" if cfg.get("pairwise") else "edited"
+
+
+class EditScorer(nn.Module):
+    """Shared-backbone binary edit scorer: encoder -> mean-pool over edit span(s) -> 2 logits.
+    Inference twin of spellchecker.reranker.EditScorer (same state_dict keys, same forward).
+    Modes: edited (v1, one span) / pairwise (v2, two encodings) / cross (v3, one joint sequence,
+    two pooled spans). `type_feature` appends a learned embedding of the (hash-bucketed) edit type."""
+
+    TYPE_BUCKETS, TYPE_DIM = 64, 32
+
+    def __init__(self, encoder_name: str, dropout: float = 0.1, mode: str = "edited",
+                 type_feature: bool = False, _build_encoder: bool = False):
+        super().__init__()
+        assert mode in ("edited", "pairwise", "cross"), mode
+        self.encoder_name = encoder_name
+        self.mode = mode
+        self.type_feature = type_feature
+        self.encoder, hidden = _backbone(encoder_name, pretrained=_build_encoder)
+        self.hidden_size = hidden
+        self.dropout = nn.Dropout(dropout)
+        feat = hidden * (1 if mode == "edited" else 2)
+        if type_feature:
+            self.type_emb = nn.Embedding(self.TYPE_BUCKETS, self.TYPE_DIM)
+            feat += self.TYPE_DIM
+        self.head = nn.Linear(feat, 2)
+
+    def _pool(self, input_ids, attention_mask, span_mask):
+        hidden = _last_hidden(self.encoder, input_ids, attention_mask)
+        m = span_mask.unsqueeze(-1).to(hidden.dtype)
+        return (hidden * m).sum(1) / m.sum(1).clamp(min=1.0)
+
+    def forward(self, input_ids, attention_mask, span_mask,
+                src_input_ids=None, src_attention_mask=None, src_span_mask=None, type_ids=None):
+        if self.mode == "cross":
+            hidden = _last_hidden(self.encoder, input_ids, attention_mask)
+
+            def pool(mask):
+                m = mask.unsqueeze(-1).to(hidden.dtype)
+                return (hidden * m).sum(1) / m.sum(1).clamp(min=1.0)
+            pooled = torch.cat([pool(span_mask), pool(src_span_mask)], dim=-1)
+        elif self.mode == "pairwise":
+            pooled = torch.cat([self._pool(input_ids, attention_mask, span_mask),
+                                self._pool(src_input_ids, src_attention_mask, src_span_mask)], dim=-1)
+        else:
+            pooled = self._pool(input_ids, attention_mask, span_mask)
+        if self.type_feature:
+            pooled = torch.cat([pooled, self.type_emb(type_ids)], dim=-1)
+        return {"logits": self.head(self.dropout(pooled))}
+
+    @classmethod
+    def load(cls, scorer_dir: str, map_location="cpu") -> "EditScorer":
+        cfg = json.load(open(os.path.join(scorer_dir, "scorer_config.json")))
+        model = cls(encoder_name=cfg["encoder_name"], mode=_resolve_mode(cfg),
+                    type_feature=cfg.get("type_feature", False), _build_encoder=False)
+        sd = torch.load(os.path.join(scorer_dir, "pytorch_model.bin"), map_location=map_location,
+                        weights_only=True)
+        model.load_state_dict(sd)
+        model.eval()
+        return model
+
+
+# -------------------------------------------------------------------------- reranking entry point
+
+@torch.no_grad()
+def _score(scorer: EditScorer, tokenizer, texts: List[str], cands: List[Tuple[int, Dict]],
+           device, batch_size: int = 64, max_len: int = 160) -> List[float]:
+    """P(edit correct) for each (sentence_index, edit). Per-mode input construction matches
+    spellchecker.reranker.RerankedPredictor._score exactly."""
+    mode = scorer.mode
+    probs: List[float] = []
+    for k in range(0, len(cands), batch_size):
+        batch = cands[k:k + batch_size]
+        if mode == "cross":
+            sep = sep_token(tokenizer)
+            items = [build_cross_input(texts[i].split(), e, sep) for i, e in batch]
+            ids, mask, span, s_span = encode_cross(tokenizer, items, max(max_len, 320))
+            kw = {"input_ids": ids.to(device), "attention_mask": mask.to(device),
+                  "span_mask": span.to(device), "src_span_mask": s_span.to(device)}
+        else:
+            items = [build_scorer_input(texts[i].split(), e) for i, e in batch]
+            ids, mask, span = encode_candidates(tokenizer, items, max_len)
+            kw = {"input_ids": ids.to(device), "attention_mask": mask.to(device),
+                  "span_mask": span.to(device)}
+            if mode == "pairwise":
+                s_items = [build_source_input(texts[i].split(), e) for i, e in batch]
+                s_ids, s_mask, s_span = encode_candidates(tokenizer, s_items, max_len)
+                kw.update(src_input_ids=s_ids.to(device), src_attention_mask=s_mask.to(device),
+                          src_span_mask=s_span.to(device))
+        if scorer.type_feature:
+            kw["type_ids"] = torch.tensor([type_bucket(e.get("type", "UNK")) for _, e in batch],
+                                          dtype=torch.long).to(device)
+        probs += scorer(**kw)["logits"].softmax(-1)[:, 1].tolist()
+    return probs
+
+
+@torch.no_grad()
+def rerank(scorer: EditScorer, tokenizer, sources: List[str], hyps: List[str], tau: float,
+           device, batch_size: int = 64, max_len: int = 160) -> List[str]:
+    """Over-generated `hyps` (tagger run at the shipped negative keep_confidence) vs `sources`:
+    extract per-edit candidates, score each, keep only P >= tau, re-apply to the source. Pointwise
+    acceptance — the shipped behaviour. Returns one corrected string per source."""
+    out = list(hyps)
+    per_sent: Dict[int, List[Dict]] = {}
+    for i, (s, h) in enumerate(zip(sources, hyps)):
+        if s == h:
+            continue
+        edits = extract_edits(s, h)
+        out[i] = s                                   # rerankable: rebuild from accepted edits only
+        if edits:
+            per_sent[i] = edits
+    if not per_sent:
+        return out
+    cands = [(i, e) for i, es in per_sent.items() for e in es]
+    probs = _score(scorer, tokenizer, sources, cands, device, batch_size, max_len)
+    accepted = defaultdict(list)
+    for (i, e), p in zip(cands, probs):
+        if p >= tau:
+            accepted[i].append(e)
+    for i, edits in accepted.items():
+        out[i] = " ".join(apply_edits(sources[i].split(), edits))
+    return out

tokenizer_config.json

@@ -0,0 +1,11 @@
+{
+  "backend": "tokenizers",
+  "bos_token": "<|startoftext|>",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "is_local": false,
+  "mask_token": "<|mask|>",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "<|pad|>",
+  "tokenizer_class": "TokenizersBackend"
+}