NoaberAI
/

arlo-classify

@@ -1,163 +1,166 @@
----
-language: nl
-license: mit
-base_model: microsoft/mdeberta-v3-base
-pipeline_tag: zero-shot-classification
-tags:
-  - zero-shot-classification
-  - text-classification
-  - natural-language-inference
-  - dutch
-  - nederlands
----
-# Arlo Classify 1.0
-**Arlo** is een Nederlandse modelfamilie voor snelle, getypeerde beslissingen.
-Waar een taalmodel tekst genereert die je daarna moet interpreteren, geeft Arlo
-direct een waarde terug waar software mee kan werken — een label, een getal, een
-veld — altijd met een confidence score.
-Dit model dekt twee van de vier Arlo-primitieven: **Choice** (kiezen uit opties)
-en **Noul** (hoe waar is een stelling).
-## Waarom dit anders is dan een taalmodel
-Een LLM beantwoordt zo'n vraag door token voor token tekst te genereren. Dat
-kost tijd, kost geld per token, en levert output op die je nog moet parsen —
-met het risico dat er iets terugkomt dat niet in je schema past.
-Arlo doet per vraag **één forward pass** door een encoder-model van 280M
-parameters. Het genereert niets; het weegt de vraag tegen de tekst en geeft een
-score. Daardoor:
-- **snel**: tientallen milliseconden per vraag, ook op een CPU
-- **voorspelbaar**: de uitkomst is altijd een label uit jouw lijst of een getal
-  tussen 0 en 1 — nooit iets daarbuiten
-- **lokaal draaibaar**: geen API-aanroep nodig, dus geschikt voor situaties waar
-  data de deur niet uit mag
-- **zonder tokenkosten**: je draait het zelf
-## Gebruik
-```python
-from transformers import AutoModel, AutoTokenizer
-model = AutoModel.from_pretrained("NoaberAI/arlo-classify", trust_remote_code=True)
-tokenizer = AutoTokenizer.from_pretrained("NoaberAI/arlo-classify")
-```
-### Choice — kiezen uit opties
-De opties geef je pas op het moment van gebruik mee. Er is geen hertraining
-nodig om een nieuwe categorie-indeling te gebruiken: je verandert simpelweg de
-lijst.
-```python
-model.choice(tokenizer,
-    "Kan ik mijn abonnement een maand pauzeren?",
-    ["klacht", "vraag", "compliment"])
-# [{"label": "vraag",      "confidence": 0.68},
-#  {"label": "klacht",     "confidence": 0.18},
-#  {"label": "compliment", "confidence": 0.15}]
-model.choice(tokenizer,
-    "De stoeptegels op de Molenstraat liggen los.",
-    ["openbare ruimte", "vergunningen", "burgerzaken", "belastingen", "sociaal domein"])
-# [{"label": "openbare ruimte", "confidence": 0.61}, ...]
-```
-Voor gevallen waar meerdere labels tegelijk waar kunnen zijn:
-```python
-model.choice(tokenizer, tekst, labels, multi_label=True)
-```
-### Noul — hoe waar is deze stelling?
-Noul geeft een waarheidsgraad tussen 0 en 1 in plaats van een hard ja/nee, zodat
-je zelf de drempel bepaalt die bij jouw proces past.
-```python
-model.noul(tokenizer,
-    "Er ligt een gaslek open op straat, mensen worden geëvacueerd!",
-    "Dit is een spoedeisende melding.")
-# {"truth": 0.72}
-model.noul(tokenizer,
-    "Dit is niet urgent, maar de bank in het park kan wel geschilderd worden.",
-    "Dit is een spoedeisende melding.")
-# {"truth": 0.16}
-```
-### Zonder trust_remote_code
-Het model is een gewone NLI-classifier, dus de standaardpipeline werkt ook:
-```python
-from transformers import pipeline
-classifier = pipeline("zero-shot-classification", model="NoaberAI/arlo-classify")
-classifier("De put op de Kerkstraat is verstopt.",
-           candidate_labels=["verkeer", "riolering", "afval"])
-```
-## Hoe het werkt
-Het model is getraind als natural language inference-classifier: het krijgt een
-tekst en een stelling, en bepaalt of die stelling volgt uit de tekst
-(*entailment*), eruit weersproken wordt (*contradiction*), of geen van beide
-(*neutral*).
-Beide primitieven bouwen daarop voort:
-- **Choice** zet elk label om in een stelling ("Dit gaat over riolering.") en
-  vergelijkt de entailment-scores. Daardoor werkt het zero-shot met elke
-  labelverzameling die je meegeeft.
-- **Noul** neemt je stelling rechtstreeks en normaliseert entailment tegen
-  contradiction tot één waarheidsgraad.
-## De Arlo-familie
-Arlo bestaat uit drie modellen die samen een complete laag vormen voor
-gestructureerde beslissingen. Ze delen dezelfde backbone-architectuur en
-hetzelfde output-contract — een waarde plus een confidence — en zijn
-onafhankelijk of gecombineerd te gebruiken.
-| Model | Primitieven | Waarvoor |
-|---|---|---|
-| **[arlo-classify](https://huggingface.co/NoaberAI/arlo-classify)** | Choice, Noul | categoriseren, routeren, waarheidsvragen |
-| [arlo-score](https://huggingface.co/NoaberAI/arlo-score) | Score | numeriek beoordelen tegen een rubric |
-| [arlo-extract](https://huggingface.co/NoaberAI/arlo-extract) | Extraction | getypeerde velden uit tekst halen |
-Eén binnenkomende tekst door alle drie halen geeft in één keer een volledig
-gestructureerd beeld:
-```python
-tekst = ("Al drie dagen ligt er een dode boom over het fietspad aan de "
-         "Dorpsstraat, gevaarlijke situatie voor fietsers, graag snel actie.")
-classify.choice(tokenizer_c, tekst, ["openbare ruimte", "vergunningen", "burgerzaken"])
-# [{"label": "openbare ruimte", "confidence": 0.75}, ...]
-classify.noul(tokenizer_c, tekst, "Dit is een spoedeisende melding.")
-# {"truth": 0.77}
-extract.extract(tokenizer_e, tekst, "Waar is het probleem?")
-# {"value": "Dorpsstraat", "confidence": 1.00}
-```
-Van vrije tekst naar een compleet ingevuld formulier, in een fractie van de tijd
-die een taalmodel nodig heeft — en zonder dat er iets te parsen valt.
-## Technische details
-- **Backbone**: `microsoft/mdeberta-v3-base` (~280M parameters)
-- **Kop**: sequence classification, 3 klassen (entailment / neutral / contradiction)
-- **Taal**: Nederlands
-- **Trainingsdata**: Nederlandse natural language inference-data, aangevuld met
-  domeinspecifieke voorbeelden uit overheid en klantenservice
-- **Hardware**: getraind op een NVIDIA A100
-- **Licentie**: MIT
-Gemaakt door [NoaberAI](https://huggingface.co/NoaberAI).

+---
+language: nl
+license: mit
+base_model: microsoft/mdeberta-v3-base
+pipeline_tag: zero-shot-classification
+tags:
+  - zero-shot-classification
+  - text-classification
+  - natural-language-inference
+  - dutch
+  - nederlands
+---
+# Arlo Classify 1.0
+**Arlo** is een Nederlandse modelfamilie voor snelle, getypeerde beslissingen.
+Waar een taalmodel tekst genereert die je daarna moet interpreteren, geeft Arlo
+direct een waarde terug waar software mee kan werken — een label, een getal, een
+veld — altijd met een confidence score.
+Dit model dekt twee van de vier Arlo-primitieven: **Choice** (kiezen uit opties)
+en **Noul** (hoe waar is een stelling).
+> **Probeer het direct** — [open de Arlo-demo](https://huggingface.co/spaces/joranvnbeekAI/arlo) om dit model en de
+> andere twee samen uit te proberen op je eigen tekst, zonder iets te installeren.
+## Waarom dit anders is dan een taalmodel
+Een LLM beantwoordt zo'n vraag door token voor token tekst te genereren. Dat
+kost tijd, kost geld per token, en levert output op die je nog moet parsen —
+met het risico dat er iets terugkomt dat niet in je schema past.
+Arlo doet per vraag **één forward pass** door een encoder-model van 280M
+parameters. Het genereert niets; het weegt de vraag tegen de tekst en geeft een
+score. Daardoor:
+- **snel**: tientallen milliseconden per vraag, ook op een CPU
+- **voorspelbaar**: de uitkomst is altijd een label uit jouw lijst of een getal
+  tussen 0 en 1 — nooit iets daarbuiten
+- **lokaal draaibaar**: geen API-aanroep nodig, dus geschikt voor situaties waar
+  data de deur niet uit mag
+- **zonder tokenkosten**: je draait het zelf
+## Gebruik
+```python
+from transformers import AutoModel, AutoTokenizer
+model = AutoModel.from_pretrained("NoaberAI/arlo-classify", trust_remote_code=True)
+tokenizer = AutoTokenizer.from_pretrained("NoaberAI/arlo-classify")
+```
+### Choice — kiezen uit opties
+De opties geef je pas op het moment van gebruik mee. Er is geen hertraining
+nodig om een nieuwe categorie-indeling te gebruiken: je verandert simpelweg de
+lijst.
+```python
+model.choice(tokenizer,
+    "Kan ik mijn abonnement een maand pauzeren?",
+    ["klacht", "vraag", "compliment"])
+# [{"label": "vraag",      "confidence": 0.68},
+#  {"label": "klacht",     "confidence": 0.18},
+#  {"label": "compliment", "confidence": 0.15}]
+model.choice(tokenizer,
+    "De stoeptegels op de Molenstraat liggen los.",
+    ["openbare ruimte", "vergunningen", "burgerzaken", "belastingen", "sociaal domein"])
+# [{"label": "openbare ruimte", "confidence": 0.61}, ...]
+```
+Voor gevallen waar meerdere labels tegelijk waar kunnen zijn:
+```python
+model.choice(tokenizer, tekst, labels, multi_label=True)
+```
+### Noul — hoe waar is deze stelling?
+Noul geeft een waarheidsgraad tussen 0 en 1 in plaats van een hard ja/nee, zodat
+je zelf de drempel bepaalt die bij jouw proces past.
+```python
+model.noul(tokenizer,
+    "Er ligt een gaslek open op straat, mensen worden geëvacueerd!",
+    "Dit is een spoedeisende melding.")
+# {"truth": 0.72}
+model.noul(tokenizer,
+    "Dit is niet urgent, maar de bank in het park kan wel geschilderd worden.",
+    "Dit is een spoedeisende melding.")
+# {"truth": 0.16}
+```
+### Zonder trust_remote_code
+Het model is een gewone NLI-classifier, dus de standaardpipeline werkt ook:
+```python
+from transformers import pipeline
+classifier = pipeline("zero-shot-classification", model="NoaberAI/arlo-classify")
+classifier("De put op de Kerkstraat is verstopt.",
+           candidate_labels=["verkeer", "riolering", "afval"])
+```
+## Hoe het werkt
+Het model is getraind als natural language inference-classifier: het krijgt een
+tekst en een stelling, en bepaalt of die stelling volgt uit de tekst
+(*entailment*), eruit weersproken wordt (*contradiction*), of geen van beide
+(*neutral*).
+Beide primitieven bouwen daarop voort:
+- **Choice** zet elk label om in een stelling ("Dit gaat over riolering.") en
+  vergelijkt de entailment-scores. Daardoor werkt het zero-shot met elke
+  labelverzameling die je meegeeft.
+- **Noul** neemt je stelling rechtstreeks en normaliseert entailment tegen
+  contradiction tot één waarheidsgraad.
+## De Arlo-familie
+Arlo bestaat uit drie modellen die samen een complete laag vormen voor
+gestructureerde beslissingen. Ze delen dezelfde backbone-architectuur en
+hetzelfde output-contract — een waarde plus een confidence — en zijn
+onafhankelijk of gecombineerd te gebruiken.
+| Model | Primitieven | Waarvoor |
+|---|---|---|
+| **[arlo-classify](https://huggingface.co/NoaberAI/arlo-classify)** | Choice, Noul | categoriseren, routeren, waarheidsvragen |
+| [arlo-score](https://huggingface.co/NoaberAI/arlo-score) | Score | numeriek beoordelen tegen een rubric |
+| [arlo-extract](https://huggingface.co/NoaberAI/arlo-extract) | Extraction | getypeerde velden uit tekst halen |
+Eén binnenkomende tekst door alle drie halen geeft in één keer een volledig
+gestructureerd beeld:
+```python
+tekst = ("Al drie dagen ligt er een dode boom over het fietspad aan de "
+         "Dorpsstraat, gevaarlijke situatie voor fietsers, graag snel actie.")
+classify.choice(tokenizer_c, tekst, ["openbare ruimte", "vergunningen", "burgerzaken"])
+# [{"label": "openbare ruimte", "confidence": 0.75}, ...]
+classify.noul(tokenizer_c, tekst, "Dit is een spoedeisende melding.")
+# {"truth": 0.77}
+extract.extract(tokenizer_e, tekst, "Waar is het probleem?")
+# {"value": "Dorpsstraat", "confidence": 1.00}
+```
+Van vrije tekst naar een compleet ingevuld formulier, in een fractie van de tijd
+die een taalmodel nodig heeft — en zonder dat er iets te parsen valt.
+## Technische details
+- **Backbone**: `microsoft/mdeberta-v3-base` (~280M parameters)
+- **Kop**: sequence classification, 3 klassen (entailment / neutral / contradiction)
+- **Taal**: Nederlands
+- **Trainingsdata**: Nederlandse natural language inference-data, aangevuld met
+  domeinspecifieke voorbeelden uit overheid en klantenservice
+- **Hardware**: getraind op een NVIDIA A100
+- **Licentie**: MIT
+Gemaakt door [NoaberAI](https://huggingface.co/NoaberAI).