Zoeken op betekenis versus zoeken op trefwoord
Op deze pagina
Doelstellingen
- Inzicht krijgen in de beperkingen van zoeken op trefwoord
- Ontdekken hoe zoeken op betekenis deze problemen oplost
- Een eenvoudige semantische zoekfunctie implementeren
De grenzen van zoeken op trefwoord
Klassiek zoeken—TF-IDF, BM25, Elasticsearch—berust op lexicale matching: het zoekt naar de exacte woorden uit de query binnen de documenten. Dit mechanisme is snel, voorspelbaar en volkomen betrouwbaar zolang de gebruiker dezelfde woordenschat hanteert als de documenten. Het probleem is dat dit bijna nooit het geval is.
De kleine, van commentaar voorziene corpus hieronder toont de vier typische situaties bij de query “how to feed a puppy”.
# Keyword search
query = "how to feed a puppy"
# ✅ Found: contains the same words
doc_a = "How to feed a 3-month-old puppy"
# ❌ Not found: different words, same meaning
doc_b = "Feeding the young dog"
# ❌ Not found: rephrasing
doc_c = "Dietary regimen for newborn puppies"
# ⚠️ False positive: same words, different meaning
doc_d = "How to feed a startup project like a puppy"
Alleen het eerste document wordt teruggevonden, terwijl het tweede en derde de vraag even goed beantwoorden. Erger nog: het vierde document scoort hoog louter omdat het woorden deelt met de query, hoewel het over bedrijfsmanagement gaat. Synoniemen, herformuleringen en ambiguïteit: lexicaal zoeken faalt op alle drie de punten.
Zoeken op betekenis
Zoeken op betekenis vergelijkt de betekenis van teksten, niet hun woorden. U codeert het corpus eenmalig, codeert de query wanneer deze binnenkomt, en rangschikt de documenten op basis van gelijkenis.
from openai import OpenAI
import numpy as np
client = OpenAI()
def embed(text: str) -> np.ndarray:
response = client.embeddings.create(
input=text,
model="text-embedding-3-large"
)
return np.array(response.data[0].embedding)
# Corpus
documents = [
"How to feed a 3-month-old puppy",
"Feeding the young dog",
"Dietary regimen for newborn puppies",
"How to feed a startup project like a puppy",
"The basics of Italian cuisine",
]
# Index the corpus
corpus_embeddings = np.array([embed(doc) for doc in documents])
# Search
query = "how to feed a puppy"
query_embedding = embed(query)
# Calculate similarities
similarities = corpus_embeddings @ query_embedding
# Sort by relevance
results = sorted(
enumerate(similarities), key=lambda x: x[1], reverse=True
)
for idx, score in results:
print(f"{score:.4f} | {documents[idx]}")
Verwacht resultaat:
0.9123 | How to feed a 3-month-old puppy
0.8756 | Dietary regimen for newborn puppies
0.8421 | Feeding the young dog
0.4532 | How to feed a startup project like a puppy
0.1245 | The basics of Italian cuisine
De drie relevante documenten bezetten de bovenste drie plekken ondanks volledig verschillende formuleringen, en de false positive zakt naar 0,45—ruim onder de drempel die nodig zou zijn om bovenaan te komen. Het model begreep dat “puppy” hier als vergelijking dient, niet als onderwerp.
Gestructureerde vergelijking
| Criterium | Trefwoorden (BM25) | Semantisch (embeddings) |
|---|---|---|
| Synoniemen | ❌ Faalt | ✅ Werkt |
| Herformulering | ❌ Faalt | ✅ Werkt |
| Meertalig | ❌ Onmogelijk | ✅ Mogelijk |
| Spelfouten | ❌ Faalt | ✅ Verdraagt |
| Exacte match | ✅ Uitstekend | ⚠️ Soms onnauwkeurig |
| Eigennamen, codes | ✅ Uitstekend | ⚠️ Kan verwarren |
| Snelheid (groot corpus) | ✅ Zeer snel | ⚠️ Vereist een index |
| Kosten | ✅ Gratis | ⚠️ API-calls |
Wanneer welke methode gebruiken?
Uit de tabel volgt een eenvoudige regel: hoe meer een query op een identifier lijkt, des te geschikter lexicaal zoeken wordt. Een productreferentie zoals XR-4471-B, een datum, een exacte categorie of een zeldzame eigennaam zoekt u woord voor woord; een embedding-model zal die referentie al snel verwarren met naburige termen. Dit is ook de standaardkeuze wanneer het corpus enorm is en het budget voor embeddings nul bedraagt.
Zoeken op betekenis neemt het voortouw zodra de gebruiker zich in natuurlijke taal uitdrukt. Een FAQ, klantenservice, technische documentatie geraadpleegd door niet-specialisten, een meertalig corpus waarin de vraag in het Frans wordt gesteld en het antwoord in het Engels is geschreven, of zelfs een vage, verkennende query: in al deze gevallen is het gat tussen de woordenschat van de gebruiker en die van de documenten precies wat embeddings weten te overbruggen.
Omdat deze twee profielen elkaar aanvullen in plaats van concurreren, bestaat de beste aanpak vaak uit het combineren van beide methoden om alle gevallen te dekken. Dat is het onderwerp van Les 9.
Een volledige semantische zoekfunctie implementeren
In de praktijk kapselt u indexering en querying in een kleine klasse in. Dit voorkomt dat u de corpusvectoren voor elke query opnieuw berekent—de kostbaarste fout die beginners maken.
class SemanticSearch:
def __init__(self, model: str = "text-embedding-3-large"):
self.client = OpenAI()
self.model = model
self.documents: list[dict] = []
self.embeddings: np.ndarray | None = None
def index(self, documents: list[dict]):
"""Indexes a list of documents {id, text, ...}."""
self.documents = documents
texts = [d["text"] for d in documents]
response = self.client.embeddings.create(
input=texts,
model=self.model
)
vectors = sorted(response.data, key=lambda x: x.index)
self.embeddings = np.array(
[v.embedding for v in vectors], dtype=np.float32
)
def search(self, query: str, k: int = 5) -> list[dict]:
"""Searches for the k most relevant documents."""
query_emb = self.client.embeddings.create(
input=query,
model=self.model
).data[0].embedding
similarities = self.embeddings @ np.array(query_emb)
top_k = np.argsort(similarities)[-k:][::-1]
return [
{**self.documents[i], "score": float(similarities[i])}
for i in top_k
]
# Usage
engine = SemanticSearch()
engine.index([
{"id": 1, "text": "How to install Python on Windows"},
{"id": 2, "text": "Guide to configuring the Python environment"},
{"id": 3, "text": "The basics of the Python language"},
])
results = engine.search("set up Python on my PC")
for r in results:
print(f"[{r['score']:.3f}] {r['text']}")
Test deze engine met de query “set up Python on my PC”: geen van deze vijf woorden komt voor in document 1, dat spreekt over “installing Python on Windows”. Toch zou dit document als eerste moeten ranken. Wijzig vervolgens de query zodat deze gaat over “configuring the environment” en zie hoe de rangorde verschuift naar document 2—u heeft nu een minimale testopstelling om het gedrag van uw index te verifiëren voordat u deze serieus vult.
Belangrijkste punten
- Zoeken op trefwoord faalt bij synoniemen en herformuleringen
- Zoeken op betekenis vergelijkt betekenis via embeddings
- Elke aanpak heeft zijn sterke punten: hybride zoeken combineert beide
- Een eenvoudige semantische engine bouwt u in enkele tientallen regels code