Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Vyhledávání podle významu vs. vyhledávání podle klíčových slov

Lekce 6 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Cíle
  2. Omezení vyhledávání podle klíčových slov
  3. Vyhledávání podle významu
  4. Strukturované srovnání
  5. Kdy použít které?
  6. Implementace kompletního sémantického vyhledávání
  7. Klíčové poznatky

Cíle

  • Pochopit omezení vyhledávání podle klíčových slov
  • Zjistit, jak vyhledávání podle významu tyto problémy řeší
  • Implementovat jednoduché sémantické vyhledávání

Omezení vyhledávání podle klíčových slov

Klasické vyhledávání – TF-IDF, BM25, Elasticsearch – spoléhá na lexikální shodu: hledá přesná slova z dotazu přímo v dokumentech. Tento mechanismus je rychlý, předvídatelný a dokonale spolehlivý, pokud uživatel používá stejnou slovní zásobu jako dokumenty. Problém je, že to téměř nikdy nedělá.

Níže uvedený malý komentovaný korpus ukazuje čtyři typické situace při zadání dotazu „jak krmit štěně“.

# 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"

Načte se pouze první dokument, přestože druhý a třetí odpovídají na otázku stejně dobře. Horší je, že čtvrtý dokument se umístí vysoko pouze proto, že sdílí slova s dotazem, i když pojednává o řízení podniku. Synonyma, přeformulování a nejednoznačnost: lexikální vyhledávání selhává ve všech třech případech.

Vyhledávání podle významu

Sémantické vyhledávání porovnává význam textů, nikoliv jejich slova. Korpus zakóduješ jednou provždy, dotaz zakóduješ v momentě jeho příchodu a dokumenty seřadíš podle podobnosti.

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]}")

Očekávaný výsledek:

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

Tři relevantní dokumenty obsadí první tři místa navzdory zcela odlišnému formulování a falešně pozitivní výsledek klesne na 0,45 – hluboko pod práh, který by ho dostal na vrchol. Model pochopil, že slovo „štěně“ zde slouží jako přirovnání, nikoliv jako předmět diskuse.

Strukturované srovnání

KritériumKlíčová slova (BM25)Sémantika (embeddings)
Synonyma❌ Selhává✅ Funguje
Přeformulování❌ Selhává✅ Funguje
Vícejazyčnost❌ Nemožné✅ Možné
Překlepy❌ Selhává✅ Toleruje
Přesná shoda✅ Vynikající⚠️ Někdy nepřesné
Vlastní jména, kódy✅ Vynikající⚠️ Může si plést
Rychlost (velký korpus)✅ Velmi rychlé⚠️ Vyžaduje index
Náklady✅ Zdarma⚠️ Volání API

Kdy použít které?

Čtení tabulky nabízí jednoduché pravidlo: čím blíže je dotaz identifikátoru, tím vhodnější je lexikální vyhledávání. Odkaz na produkt jako XR-4471-B, datum, přesná kategorie nebo vzácné vlastní jméno by se mělo hledat slovo od slova; model embeddings má tendenci si tento odkaz plést s jeho okolím. Je to také výchozí volba, když je korpus obrovský a rozpočet na embeddings nulový.

Sémantické vyhledávání přebírá vedení, jakmile se uživatel vyjadřuje přirozeným jazykem. FAQ, zákaznická podpora, technická dokumentace konzultovaná neodborníky, vícejazyčný korpus, kde je otázka položena francouzsky a odpověď napsána anglicky, nebo dokonce vágní, explorativní dotaz: ve všech těchto případech je propast mezi slovní zásobou uživatele a slovní zásobou dokumentů přesně tím, co embeddings umí překlenout.

Protože jsou tyto dva profily spíše komplementární než konkurenční, nejlepší odpověď často spočívá v kombinaci obou přístupů, aby byly pokryty všechny případy. To je tématem Lekce 9.

Implementace kompletního sémantického vyhledávání

V praxi zapouzdříš indexování a dotazování do malé třídy. Tím se vyhneš přepočítávání vektorů korpusu pro každý dotaz – což je nejdražší chyba, které se začátečníci dopouštějí.

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']}")

Otestuj tento engine dotazem „set up Python on my PC“: žádné z těchto pěti slov se v dokumentu 1 nevyskytuje, který hovoří o „installing Python on Windows“. Přesto by se měl umístit na první místo. Poté uprav dotaz tak, aby hovořil o „configuring the environment“, a sleduj, jak se pořadí posune k dokumentu 2 – nyní máš minimální testovací prostředí pro ověření chování svého indexu před tím, než jej vážně naplníš daty.

Klíčové poznatky

  • Vyhledávání podle klíčových slov selhává u synonym a přeformulování
  • Sémantické vyhledávání porovnává význam pomocí embeddings
  • Každý přístup má své silné stránky: hybridní vyhledávání kombinuje oba
  • Jednoduchý sémantický engine lze postavit na několika desítkách řádků