Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Szemantikus keresés vs. kulcsszavas keresés

6. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Célok
  2. A kulcsszavas keresés korlátai
  3. Szemantikus keresés
  4. Strukturált összehasonlítás
  5. Mikor melyiket használd?
  6. Teljes szemantikus keresés implementálása
  7. Főbb megállapítások

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ériumKulcsszavas (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ő