Szemantikus keresés vs. kulcsszavas keresés
Ezen az oldalon
Célok
- Megérteni a kulcsszavas keresés korlátait
- Felfedezni, hogyan oldja meg ezeket a problémákat a szemantikus keresés
- Implementálni egy egyszerű szemantikus keresőt
A kulcsszavas keresés korlátai
A klasszikus keresés – TF-IDF, BM25, Elasticsearch – lexikális egyezéseken alapul: a lekérdezésben szereplő pontos szavakat keresi a dokumentumokban. Ez a mechanizmus gyors, kiszámítható és tökéletesen megbízható mindaddig, amíg a felhasználó ugyanazt a szókincset használja, mint a dokumentumok. A probléma az, hogy ezt szinte sosem teszik.
Az alábbi kis kommentezett korpusz bemutatja azt a négy tipikus helyzetet, amikor a „how to feed a puppy“ (hogyan etessünk egy kiskutyát) lekérdezéssel állunk szemben.
# 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"
Csak az első dokumentum kerül elő, pedig a második és a harmadik ugyanolyan jól megválaszolná a kérdést. Ami még rosszabb: a negyedik dokumentum magas rangot kap pusztán azért, mert közös szavakat tartalmaz a lekérdezéssel, noha üzleti menedzsmentről szól. Szinonimák, átfogalmazások és kétértelműség: a lexikális keresés mindhárom területen kudarcot vall.
Szemantikus keresés
A szemantikus keresés a szövegek jelentését hasonlítja össze, nem a szavaikat. A korpuszt egyszer és mindenkorra kódolod (embed), a lekérdezést pedig beérkezéskor kódolod, majd a dokumentumokat hasonlóság alapján rangsorolod.
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]}")
Várt eredmény:
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
A három releváns dokumentum foglalja el az első három helyet a teljesen eltérő megfogalmazások ellenére is, míg a hamis találat értéke 0,45-re csökken – jóval az alá a küszöb alá, ami az élre repítené. A modell megértette, hogy itt a „puppy“ (kiskutya) szó összehasonlításként szolgál, nem pedig alanyként.
Strukturált összehasonlítás
| Kritérium | Kulcsszavas (BM25) | Szemantikus (beágyazások) |
|---|---|---|
| Szinonimák | ❌ Kudarc | ✅ Működik |
| Átfogalmazás | ❌ Kudarc | ✅ Működik |
| Többnyelvűség | ❌ Lehetetlen | ✅ Lehetséges |
| Helyesírási hibák | ❌ Kudarc | ✅ Tűri |
| Pontos egyezés | ✅ Kiváló | ⚠️ Néha pontatlan |
| Tulajdonnevek, kódok | ✅ Kiváló | ⚠️ Összekeverheti |
| Sebesség (nagy korpusz) | ✅ Nagyon gyors | ⚠️ Indexelést igényel |
| Költség | ✅ Ingyenes | ⚠️ API-hívások |
Mikor melyiket használd?
A táblázat olvasása egy egyszerű szabályhoz vezet: mininkább egy azonosítóhoz hasonlít egy lekérdezés, annál inkább a lexikális keresés a megfelelő. Egy XR-4471-B típusú termékhivatkozás, egy dátum, egy pontos kategória vagy egy ritka tulajdonnév esetén szóról szóra kell keresni; egy beágyazási modell hajlamos lesz összekeverni ezt a hivatkozást a szomszédos elemekkel. Ez az alapértelmezett választás akkor is, ha a korpusz hatalmas, és a beágyazási költségvetés nulla.
A szemantikus keresés veszi át a vezető szerepet, amint a felhasználó természetes nyelven fejezi ki magát. GYIK, ügyfélszolgálat, nem szakemberek által konzultált műszaki dokumentáció, többnyelvű korpusz, ahol a kérdést franciául teszik fel, a választ pedig angolul írták, vagy akár egy bizonytalan, felfedező jellegű lekérdezés: mindezekben az esetekben a felhasználó szókincse és a dokumentumok szókincse közötti szakadékot pontosan a beágyazások hidalják át.
Mivel ez a két profil inkább kiegészíti, mintsem versenyez egymással, a legjobb válasz gyakran mindkét megközelítés kombinálásából áll, hogy minden esetet lefedjünk. Erről szól a 9. lecke.
Teljes szemantikus keresés implementálása
A gyakorlatban az indexelést és a lekérdezést egy kis osztályba csomagolod. Ezzel elkerülöd, hogy minden egyes lekérdezésnél újra kiszámold a korpusz vektorait – ez a legköltségesebb hiba, amit a kezdők elkövetnek.
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']}")
Teszteld ezt a motort a „set up Python on my PC“ lekérdezéssel: ebből az öt szóból egyik sem szerepel az 1. dokumentumban, amely a „Python telepítéséről Windowsra“ szól. Ennek ellenére az első helyen kellene szerepelnie. Ezután módosítsd a lekérdezést úgy, hogy a „környezet konfigurálásáról“ szóljon, és figyeld meg, ahogy a rangsor a 2. dokumentumra vált – így már van egy minimális tesztkörnyezeted, amellyel ellenőrizheted az indexed viselkedését, mielőtt komolyan feltöltenéd adatokkal.
Főbb megállapítások
- A kulcsszavas keresés kudarcot vall a szinonimáknál és az átfogalmazásoknál
- A szemantikus keresés a beágyazásokon keresztül a jelentést hasonlítja össze
- Mindkét megközelítésnek megvannak az erősségei: a hibrid keresés egyesíti őket
- Egy egyszerű szemantikus motor néhány tucat sor kódból felépíthető