Programma Les 196 van 250 · De ML rondom de LLM
De ML rondom de LLM

Intent Classificatie (TF-IDF + LogisticRegression)

Niet elke "AI feature" heeft een large language model nodig. Een groot deel van productie LLM apps zet een kleine, saaie classifier vóór het model: het leest het binnenkomende bericht, beslist wat voor soort verzoek het is (facturering? een bug rapport? een wijziging van het account?) en routeert dienovereenkomstig. Die beslissing is snel, gratis, draait offline en is deterministisch -> dezelfde input geeft altijd hetzelfde antwoord. Je maakt pas een dure LLM call wanneer je er echt een nodig hebt.

De werkpaard voor korte tekst is TfidfVectorizer + LogisticRegression. TF-IDF zet elk bericht om in een sparse vector van gewogen woordtellingen; logistic regression leert een lineaire grens tussen de intent classes. Op een paar tientallen gelabelde voorbeelden traint het in milliseconden en classificeert het in microseconden.

Je gaat de twee verbinden tot één object met een Pipeline zodat de vectorizer en de classifier samen als een eenheid passen en worden toegepast:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline

pipe = Pipeline([
    ("tfidf", TfidfVectorizer()),
    ("clf", LogisticRegression(random_state=0, max_iter=1000)),
])
pipe.fit(texts, labels)
pipe.predict(["can I get a refund"])   # -> array(['billing'])

Waarom random_state=0? Een gewoonte die het waard is om te hebben. De standaard solver hier (lbfgs) is deterministisch, dus deze pipeline geeft dezelfde weights met of zonder een seed. Maar andere solvers (saga, liblinear) husselen de data, en veel scikit-learn modellen (random forests, k-means, train/test splits) zijn per ontwerp willekeurig; daar is de seed wat de training reproduceerbaar maakt. Het overal opschrijven betekent dat een latere wijziging van solver of model je routing niet onopgemerkt kan laten wisselen tussen runs. De cursus volgt deze regel overal.

Dit is precies het contrast met de LLM. Een model call is niet-deterministisch, kost geld en voegt latentie toe. Hier is het soort fallback dat je downstream zou kunnen aansluiten zodra je de intent weet (getoond voor context, nooit beoordeeld):

# Pseudocode: only AFTER the cheap classifier is unsure do you reach for the model.
intent = pipe.predict([msg])[0]
if intent == "general":
    reply = await window._floatiTutor.complete(msg)   # the on-device LLM

Bouw twee functies. train_classifier(texts, labels) geeft een gefitte Pipeline (TF-IDF + LogisticRegression met random_state=0) terug. predict(model, new_texts) neemt dat model en een list van strings en geeft een list van voorspelde labels terug. Druk op Run om te trainen op een kleine set support-tickets en kijk hoe het vastgehouden berichten naar het juiste team routeert.

Jij bent aan de beurt

Schrijf train_classifier(texts, labels) die een gefitte sklearn Pipeline van TfidfVectorizer() retourneert en dan LogisticRegression(random_state=0, ...), en predict(model, new_texts) die een lijst met voorspelde labels retourneert voor een lijst van input strings. De seed maakt het reproduceerbaar; de classifier moet verschillende vastgehouden berichten naar hun juiste intenties sturen. Houd de TEXTS en LABELS van de starter zoals ze zijn: de check leest ze.

Een probleem ontdekt in deze les? Meld het · Vraag naar deze les

Deze oefening opent binnenkort

Maak de les ervoor af voordat deze wordt ontgrendeld. De hele cursus is gratis, geen account nodig, en je kunt deze les nu lezen.