README.md

---

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
  - multilingual
---


# 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).

## Arlo in actie

<video controls loop muted playsinline src="https://huggingface.co/NoaberAI/arlo-classify/resolve/main/demo.mp4"></video>

## 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.

## Ook op andere talen

Het model is op Nederlands getraind, maar de backbone (`mdeberta-v3-base`) is
multilingual en dat blijft merkbaar: dezelfde melding in vijf talen levert
vrijwel dezelfde uitkomst op.

```python

labels = ["openbare ruimte", "belastingen", "burgerzaken"]



model.choice(tok, "De straatlamp voor mijn huis is kapot.", labels)          # 0.68

model.choice(tok, "The streetlight in front of my house is broken.", labels) # 0.69

model.choice(tok, "Die Straßenlaterne vor meinem Haus ist kaputt.", labels)  # 0.71

model.choice(tok, "Le lampadaire devant ma maison est cassé.", labels)       # 0.67

model.choice(tok, "La farola delante de mi casa está rota.", labels)         # 0.66

```

Alle vijf kiezen `openbare ruimte`. Je labels en stellingen mag je in het
Nederlands laten staan, ook als de tekst dat niet is — voor Noul werkt dat zelfs
beter dan de stelling meevertalen:

```python

tekst = "There is a tree across the road, very dangerous!"



model.noul(tok, tekst, "Dit is een spoedeisende melding.")  # {"truth": 0.87}

model.noul(tok, tekst, "This is an urgent report.")         # {"truth": 0.61}

```

## 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).