Semantisk søgning vs. nøgleordsøgning
På denne side
Mål
- Forstå begrænsningerne ved nøgleordsøgning
- Opdag, hvordan semantisk søgning løser disse problemer
- Implementer en simpel semantisk søgning
Begrænsningerne ved nøgleordsøgning
Klassisk søgning – TF-IDF, BM25, Elasticsearch – baserer sig på leksikalsk matching: den leder efter de præcise ord fra forespørgslen inde i dokumenterne. Denne mekanisme er hurtig, forudsigelig og fuldstændig pålidelig, så længe brugeren benytter samme ordforråd som dokumenterne. Problemet er, at de næsten aldrig gør det.
Det lille kommenterede korpus nedenfor viser de fire typiske situationer, når man står over for forespørgslen “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"
Kun det første dokument hentes, selvom det andet og tredje besvarer spørgsmålet lige så godt. Værre endnu: det fjerde rangerer højt udelukkende, fordi det deler ord med forespørgslen, selvom det handler om virksomhedsledelse. Synonymer, omskrivninger og tvetydighed: leksikalsk søgning fejler på alle tre punkter.
Semantisk søgning
Semantisk søgning sammenligner betydningen af tekster, ikke deres ord. Du encoder korpussen én gang for alle, encoder forespørgslen, når den ankommer, og rangerer dokumenterne efter lighed.
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]}")
Forventet resultat:
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 tre relevante dokumenter indtager de tre øverste pladser trods helt anderledes formuleringer, og falsk-positivet falder til 0,45 – langt under den tærskel, der ville bringe det til tops. Modellen forstod, at “puppy” her fungerer som en sammenligning, ikke som emnet.
Struktureret sammenligning
| Kriterium | Nøgleord (BM25) | Semantisk (embeddings) |
|---|---|---|
| Synonymer | ❌ Fejler | ✅ Virker |
| Omskrivning | ❌ Fejler | ✅ Virker |
| Flersproget | ❌ Umuligt | ✅ Muligt |
| Stavefejl | ❌ Fejler | ✅ Tolererer |
| Præcist match | ✅ Fremragende | ⚠️ Nogle gange upræcist |
| Egennavne, koder | ✅ Fremragende | ⚠️ Kan forveksle |
| Hastighed (stort korpus) | ✅ Meget hurtig | ⚠️ Kræver et indeks |
| Omkostninger | ✅ Gratis | ⚠️ API-kald |
Hvornår skal du bruge hvad?
Tabellen giver en simpel regel: Jo tættere en forespørgsel er på en identifikator, desto mere passende bliver leksikalsk søgning. En produktreference som XR-4471-B, en dato, en eksakt kategori eller et sjældent egennavn bør søges ord for ord; en embedding-model vil have tendens til at forveksle den reference med dens naboer. Dette er også standardvalget, når korpussen er massiv, og budgettet til embeddings er nul.
Semantisk søgning tager føringen, så snart brugeren udtrykker sig på naturligt sprog. En FAQ, kundesupport, teknisk dokumentation konsulteret af ikke-specialister, et flersproget korpus hvor spørgsmålet stilles på fransk og svaret er skrevet på engelsk, eller selv en vag, udforskende forespørgsel: i alle disse tilfælde er kløften mellem brugerens ordforråd og dokumenternes netop det, som embeddings ved, hvordan de skal overbridge.
Da disse to profiler er komplementære snarere end konkurrerende, består det bedste svar ofte i at kombinere begge tilgange for at dække alle tilfælde. Det er emnet for lektion 9.
Implementering af komplet semantisk søgning
I praksis kapsler du indeksering og forespørgsel i en lille klasse. Det undgår at genberegne korpus-vektorerne for hver eneste forespørgsel – den dyreste fejl, begyndere laver.
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 denne engine med forespørgslen “set up Python on my PC”: ingen af disse fem ord forekommer i dokument 1, som handler om “installing Python on Windows”. Alligevel bør det rangere først. Modificer derefter forespørgslen til at handle om “configuring the environment”, og se rangeringen skifte til dokument 2 – nu har du en minimal testbænk til at verificere dit indeks’ adfærd, før du befolker det seriøst.
Vigtige pointer
- Nøgleordsøgning fejler ved synonymer og omskrivninger
- Semantisk søgning sammenligner betydning via embeddings
- Hver tilgang har sine styrker: hybrid søgning kombinerer begge
- En simpel semantisk engine kan bygges på få dusin linjer