Download README.md from proofbird/gector-bert-nl: direct link, hf CLI and curl.
- Browser
- Download file 14.2 kB
-
https://huggingface.co/proofbird/gector-bert-nl/resolve/main/README.md
- Command line
-
hf download hf://proofbird/gector-bert-nl/README.md
-
curl -L -o README.md https://huggingface.co/proofbird/gector-bert-nl/resolve/main/README.md
license: apache-2.0
language:
- nl
base_model: GroNLP/bert-base-dutch-cased
pipeline_tag: token-classification
library_name: onnx
tags:
- grammatical-error-correction
- gector
- onnx
- on-device
- dutch
datasets:
- wikimedia/wikipedia
Proofbird Grammar — Dutch
gector-bert-nl · on-device Dutch grammar correction
Try it in your browser: type a sentence and see the corrections. The model runs on your own computer; nothing to install, and your text never leaves the page.
Version 1.0.0 · run 2026-11-15-1125 · tag v1.0.0, the files the Proofbird app downloads. Pin it with revision="v1.0.0". Versions: a change to the model's design (encoder, inputs, outputs) raises the first number, a new training run or changed guards and rules the second, card or metadata fixes the third.
A GECToR-style sequence tagger for Dutch grammatical error correction, exported to ONNX (fp32) to run on the CPU. It is the on-device grammar model of Proofbird, a writing assistant for Windows, and it is published here so anyone can inspect what runs on their machine.
GECToR does not rewrite text. For each token it predicts one edit tag (keep, delete, replace with a word, append a word, change case, change a word's ending), and the edits are applied and the sentence re-tagged up to five times. The tagger only proposes local edits; it never paraphrases.
Quick start
No API key, no GPU. One file, quickstart.py, downloads the model and runs it with ONNX Runtime.
pip install onnxruntime tokenizers huggingface_hub
import importlib.util
from huggingface_hub import hf_hub_download
spec = importlib.util.spec_from_file_location("quickstart", hf_hub_download("proofbird/gector-bert-nl", "quickstart.py"))
quickstart = importlib.util.module_from_spec(spec)
spec.loader.exec_module(quickstart)
model = quickstart.Gector("proofbird/gector-bert-nl")
corrected, suggestions = model.correct("Deze huis zijn erg mooi.")
print(corrected)
print(suggestions)
Dit huis is erg mooi.
[{"start": 0, "length": 4, "original": "Deze", "replacement": "Dit"}, {"start": 10, "length": 4, "original": "zijn", "replacement": "is"}]
Each suggestion gives the character position in your text (start, length), what is there now (original) and what to put instead (replacement), so you can underline it and offer the fix. From the command line: python quickstart.py "Deze huis zijn erg mooi." prints every step below.
What it corrects
The d/t endings of the present tense (Ik vindt → vind, Zij vind → vindt) and of the past participle (verstuurt
→ verstuurd), the past-tense suffix (praate → praatte), subject-verb agreement in person and number (Hij werken →
werkt, De kinderen speelt → spelen, Wij heeft → hebben, Er is veel mensen → Er zijn), de and het
(het stoel → de stoel), the demonstratives (Deze huis → Dit huis) and relative pronouns (het huis die → dat),
the inflected adjective (een lief hond → een lieve hond), als and dan after a comparative (groter als →
dan), subject pronouns (Hun wonen → Zij wonen) and jou/jouw, compounds written apart (tand arts →
tandarts), the trema (ideeen → ideeën), and a capital at the start of a sentence.
How it was trained
Base encoder:
GroNLP/bert-base-dutch-cased(BERTje, Apache-2.0). A tagging head (5 000 edit labels) and an error-detection head sit on top.Data: synthetic only. Three sources, 3 159 747 sentences in all:
- 1 500 000 sentences from Dutch Wikipedia
(
wikimedia/wikipedia,20231101.nl); - 1 500 000 sentences from the proceedings of the European Parliament (Europarl v7, sessions 1996 – May 2011): speech in the first and second person, questions and argument, the register encyclopedic text lacks;
- 159 747 sentences from Tatoeba, everyday Dutch (all that pass the length filter, less the sentences held out for the checks below).
They were corrupted by hand-written Dutch error rules; about 10% stay clean, so the model learns to leave correct text alone. Each rule was run over real text first and changed wherever the "error" it made also occurs as correct Dutch. 150 000 additional template sentences teach patterns the corpora rarely contain (every person of the present tense,
jij/jeafter the verb,de/hetwith an adjective,er is/er zijn).- 1 500 000 sentences from Dutch Wikipedia
(
No learner corpora and no non-commercial data in the fine-tuning. No user text was used.
One epoch (98 475 steps, batch 64, learning rate 3e-5) on one NVIDIA L4. Run id
2026-11-15-1125.
How it was measured
| Check | Result |
|---|---|
| Gold set (771 hand-written sentences: 568 with one error each, 203 correct) | 550 fixed, 203 left alone, 18 missed, 0 made worse |
| False alarms on 4 000 everyday Tatoeba sentences (held out from training) | 0 changed (0.00%) |
| False alarms on 4 000 sentences from European Parliament sessions the model never saw (June 2011) | 0 changed (0.00%) |
| Stability: the gold re-run with one extra token in front of each sentence | 2 sentences change result (the 5 capitalisation rows change by construction and are not counted) |
The scores are with the apply-side guards in gector-guards.json (below). Without them the model changes 6 Tatoeba and
3 Europarl sentences, all of them false alarms of the shapes the guards hold back. The model was trained for precision:
a missed error costs less than a wrong correction. The misses: a plural subject that is a noun does not always pull its
verb into the plural (De bomen staat is left alone), We gaat and Jullie komt, the past tense of a verb whose stem
ends in k (kookde), an inflected adjective after is (Het weer is mooie), and two irregular present forms the
guards hold back (Hij gaan, Het kind slapen). The gold set was written for this model and has not yet been
reviewed by a native speaker. It has not been measured on learner essays.
The guards. gector-guards.json holds back edits we measured as wrong in a known shape. They run in the Proofbird
app (not in quickstart.py or the demo) and are part of every score above. Among them: a verb's -t form keeps its
long vowel (gaat, slaapt, never gat, slapt); a word is deleted only when it is written twice, and dat dat,
die die, jullie jullie stay (Ik wist dat dat Tom gelukkig zou maken); dit after a form of zijn is a pronoun
(Is dit kunst?); Zei u is the verb; uw before a noun stays (Kam uw haar) and u after its verb stays (Bent u leraar?).
Files
| File | What it is |
|---|---|
model.onnx |
The tagger (fp32, opset 17). Inputs input_ids, attention_mask; outputs logits_labels [1, T, 5000] and logits_d [1, T, 2]. |
config.json |
The edit-label vocabulary (id2label). |
vocab.txt, tokenizer.json, tokenizer_config.json |
The base encoder's WordPiece tokenizer. |
gector-meta.json |
Export facts: encoder, tokenizer family, decoding defaults, run id, version. |
gector-guards.json |
Apply-side guards: rules that hold back an edit the model gets wrong in a known way (for example gaan → gat). Part of the measured result. |
language-rules.json |
Language facts the runtime needs (sentence-final punctuation handling). |
verb-form-vocab.txt |
Empty for Dutch: verb forms are corrected with ending and replacement tags, not a verb table. |
quickstart.py |
A complete Python runner: download, tokenize, run, decode, apply, suggestions. See Quick start. |
quickstart.ipynb |
The same, as a notebook (the Open in Colab button). |
The Proofbird app runs the same algorithm in C# with ONNX Runtime; the files are standard, so any GECToR-style decoder can use them.
How it works, step by step
The model never sees letters and never writes text. It reads numbers (token ids) and answers, for every word, which edit to make: one of 5 000 tags such as $KEEP, $DELETE, $APPEND_de, $REPLACE_als or $TRANSFORM_SUF__an (change a word's ending). quickstart.py does everything around it. This is the real run of the example above.
1. Prepare the text. language-rules.json says the final full stop comes off before the model sees the sentence (it goes back on at the end): Deze huis zijn erg mooi.
2. The request. The words are looked up in the model's dictionary (vocab.txt). A rare word is split into pieces; the edit is read at its first piece. [CLS] stands for a dummy first word, $START, so an edit on it can add a word at the very beginning; [SEP] marks the end.
words $START Deze huis zijn erg mooi
tokens [CLS] Deze huis zijn erg mooi [SEP]
input_ids [1, 2109, 13479, 22777, 11330, 15788, 2]
attention_mask [1, 1, 1, 1, 1, 1, 1]
Two inputs, both whole numbers (int64), shape [1, 7]: one sentence of 7 tokens.
3. The response. Two outputs (float32): logits_labels [1, 7, 5000], a score for each of the 5 000 edits at every token, and logits_d [1, 7, 2], a score for "this word is correct" and "this word is wrong". A softmax turns each row into probabilities; the most probable edit at each word's first token is the one applied.
4. Pass by pass. The corrected sentence goes back in, until a pass changes nothing (at most five passes). Connected errors are fixed one after the other.
Pass 1: Deze huis zijn erg mooi
| Word | Wrong | Chosen edit | Probability |
|---|---|---|---|
| $START | 0.0% | $KEEP | 100.0% |
| Deze | 98.7% | $REPLACE_Dit | 99.7% |
| huis | 0.0% | $KEEP | 100.0% |
| zijn | 64.9% | $REPLACE_is | 61.2% |
| erg | 0.0% | $KEEP | 100.0% |
| mooi | 0.0% | $KEEP | 100.0% |
→ Dit huis is erg mooi
Pass 2: Dit huis is erg mooi
| Word | Wrong | Chosen edit | Probability |
|---|---|---|---|
| $START | 0.0% | $KEEP | 100.0% |
| Dit | 0.0% | $KEEP | 100.0% |
| huis | 0.0% | $KEEP | 100.0% |
| is | 0.0% | $KEEP | 100.0% |
| erg | 0.0% | $KEEP | 100.0% |
| mooi | 0.0% | $KEEP | 100.0% |
→ Dit huis is erg mooi — no change, so it stops.
5. The suggestions. The original and the final words are compared, and each changed stretch becomes one suggestion with its position in the original text (unchanged text keeps its own spacing), as in the Quick start output above.
6. Settings. Gector(repo, keep_confidence=0.0, min_error_prob=0.0) takes the two GECToR precision knobs (the Proofbird app runs with both at 0, and at most five passes):
keep_confidenceadds a bonus to$KEEPbefore choosing: higher means fewer, safer edits.min_error_probignores an edit the model is less sure of, and leaves the whole sentence alone when no word is at least that likely to be wrong. Withmin_error_prob=0.9the example is still corrected (Dit huis is erg mooi.): the model is 98.7% sure one word is wrong.
What Proofbird adds
quickstart.py is the model on its own. The Proofbird app runs the same algorithm in C# and adds:
- Guards: per-language rules that hold back edits we measured as wrong in a known shape.
gector-guards.json, in this repository, lists which guards are on for Dutch and their word lists; what each guard does is code in the app. The scores under How it was measured are with the guards. - Spelling, checked separately by the operating system's spell checker; the guards use it so a grammar edit is not made on a word that is misspelled.
- A card for each change that names the error ("Subject–verb agreement") and, on request, explains it.
quickstart.py and the in-browser demo run the model on its own, without the guards.
Licence and attribution
The model weights and the files in this repository are released under the Apache License 2.0. If you redistribute the model or a model built from it, keep the NOTICE file with it (Apache-2.0, section 4(d)).
The training data carries its own terms. Wikipedia text is © Wikipedia contributors,
CC BY-SA 4.0. Tatoeba sentences are from
tatoeba.org, CC BY 2.0 FR. Contains text
from the proceedings of the European Parliament, © European Union, 1996–2011, reused under the European Parliament's
legal notice, through the Europarl corpus
(statmt.org/europarl, Philipp Koehn, Europarl: A Parallel Corpus for Statistical
Machine Translation, MT Summit 2005). The base encoder is BERTje, GroNLP/bert-base-dutch-cased, by Wietse de Vries,
Andreas van Cranenburgh, Arianna Bisazza, Tommaso Caselli, Gertjan van Noord and Malvina Nissim (University of
Groningen), Apache License 2.0: BERTje: A Dutch BERT Model, arXiv:1912.09582, 2019. The tagging scheme follows GECToR
(Omelianchuk et al., 2020, GECToR – Grammatical Error Correction: Tag, Not Rewrite).
How to cite
If you use or build on this model, please cite it:
@misc{hartnett2026gectornl,
author = {Hartnett, Patrick Andrew},
title = {Proofbird GECToR grammar model (Dutch)},
year = {2026},
publisher = {Hugging Face},
howpublished = {\url{https://huggingface.co/proofbird/gector-bert-nl}},
note = {Proofbird, https://proofbird.app}
}
If you build on this model, a link back to this page is appreciated.
Contact
Published by Patrick Andrew Hartnett as personal work. Questions and reports: open a discussion on this repository.