Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Hybridné vyhľadávanie (sémantické + lexikálne)

Lekcia 9 z 22 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Ciele
  2. Problém: žiadny jediný prístup nie je dokonalý
  3. Lexikálne vyhľadávanie s BM25
  4. Reciprocal Rank Fusion (RRF)
  5. Kompletný hybridný pipeline
  6. Natívne hybridné vyhľadávanie vo Weaviate
  7. Kľúčové poznatky

Ciele

  • Pochopiť, prečo je kombinácia sémantického a lexikálneho vyhľadávania kľúčová
  • Implementovať hybridné vyhľadávanie pomocou Reciprocal Rank Fusion (RRF)
  • Využiť hybridné vyhľadávanie vo vektorových databázach

Problém: žiadny jediný prístup nie je dokonalý

Sémantické vyhľadávanie exceluje v práci so synonymami, no často prehliadne presné technické termíny; lexikálne vyhľadávanie funguje presne naopak. Predstav si dopyt správcu systému „nginx error 503“ a sleduj, ako sa oba motory správajú voči báze technickej dokumentácie.

# Query: "nginx error 503"
# Semantic → finds "web server issues" (good) but misses "code 503" (missed)
# Lexical   → finds "nginx error 503" exactly (good) but misses "reverse proxy timeout" (missed)
# Hybrid    → finds both ✅

Sémantické vyhľadávanie pochopí, že ide o incident na serveri, a zobrazí všeobecné články, no číslo 503 mu unikne: pre model vkladania (embedding) sú 503 a 504 len dve trojciferné čísla, sémanticky blízke, hoci označujú rôzne výpadky. Lexikálne vyhľadávanie nájde presný kód, ale prehliadne článok o časových limitoch reverse proxy, ktorý často opisuje hlavnú príčinu. Ani jedna metóda sama o sebe nevráti správnu výslednú stránku; až ich zjednotenie áno.

Lexikálne vyhľadávanie s BM25

BM25 je štandardný algoritmus pre vyhľadávanie podľa kľúčových slov. Každý termín váhuje na základe jeho zriedkavosti v korpuse a frekvencie v dokumente, čím prirodzene zvýrazňuje diskriminačné termíny ako „503“ alebo „nginx“. Musíš mu však dodať čisté tokeny: funkcia na tokenizáciu prevedie text na malé písmená, extrahuje slová a odstráni slovenské stop slová, ktoré neprinášajú žiadny signál relevance.

from rank_bm25 import BM25Okapi
import re

def tokenize(text: str) -> list[str]:
    """Jednoduchá tokenizácia pre slovenčinu."""
    text = text.lower()
    tokens = re.findall(r"\b\w+\b", text)
    # Odstránenie bežných stop slov
    stop_words = {"le", "la", "les", "de", "du", "des", "un", "une",
                  "et", "ou", "est", "dans", "pour", "avec", "sur"}
    return [t for t in tokens if t not in stop_words]

documents = [
    "Comment résoudre l'erreur 503 dans nginx",
    "Configuration du reverse proxy avec timeout",
    "Guide d'installation de nginx sur Ubuntu",
    "Les bases de la cuisine française",
]

# Indexovanie s BM25
tokenized_corpus = [tokenize(doc) for doc in documents]
bm25 = BM25Okapi(tokenized_corpus)

# Vyhľadávanie
query_tokens = tokenize("erreur 503 nginx")
bm25_scores = bm25.get_scores(query_tokens)

for i, score in enumerate(bm25_scores):
    print(f"BM25 {score:.3f} | {documents[i]}")

Reciprocal Rank Fusion (RRF)

Teraz potrebuješ skombinovať tieto dva rebríčky, čo je zložitejšie, než sa zdá: kozínusové skóre sa pohybuje medzi 0 a 1, zatiaľ čo skóre BM25 nemá hornú hranicu. Ich priame sčítanie by umožnilo BM25 úplne potlačiť sémantický signál. RRF tento problém obchádza ignorovaním surových skóre a zachovaním iba poradia: každý dokument dostane v každom zozname hodnotu 1 / (k + rank) a tieto príspevky sčítaš. Dokument, ktorý sa umiestni vysoko všade, tak porazí dokument, ktorý exceluje len v jednom zozname.

def reciprocal_rank_fusion(
    result_lists: list[list[tuple[int, float]]],
    k: int = 60
) -> list[tuple[int, float]]:
    """Zlúči viacero zoznamov výsledkov pomocou RRF.

    Args:
        result_lists: zoznam zoznamov tvaru (doc_id, score)
        k: konštanta RRF (60 je štandard)
    """
    fused_scores: dict[int, float] = {}

    for results in result_lists:
        for rank, (doc_id, _) in enumerate(results):
            if doc_id not in fused_scores:
                fused_scores[doc_id] = 0.0
            fused_scores[doc_id] += 1.0 / (k + rank + 1)

    # Zoradenie podľa skóre zostupne
    return sorted(
        fused_scores.items(),
        key=lambda x: x[1],
        reverse=True
    )

Konštanta k, konvenčne nastavená na 60 na základe literatúry, tlmí rozdiel medzi najvyššími pozíciami: bez nej by prvá pozícia vážila dvakrát toľko ako druhá, čo by robilo fúziu príliš citlivou na drobné rozdiely v poradiach.

Kompletný hybridný pipeline

Nižšie uvedená trieda udržiava oba indexy paralelne nad rovnakým korpusom, spúšťa obe vyhľadávania pre každý dopyt a fusionuje výsledné poradia. Vracia aj individuálne skóre – cenný detail počas ladenia, keďže ich porovnanie ukáže, ktorý engine niesol daný výsledok.

from openai import OpenAI
from rank_bm25 import BM25Okapi
import numpy as np

class HybridSearch:
    def __init__(self, model: str = "text-embedding-3-large"):
        self.client = OpenAI()
        self.model = model
        self.documents: list[str] = []
        self.embeddings: np.ndarray | None = None
        self.bm25: BM25Okapi | None = None

    def index(self, documents: list[str]):
        self.documents = documents

        # Sémantický index
        response = self.client.embeddings.create(
            input=documents, 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
        )

        # BM25 index
        tokenized_corpus = [tokenize(d) for d in documents]
        self.bm25 = BM25Okapi(tokenized_corpus)

    def search(
        self, query: str, k: int = 5,
        semantic_weight: float = 0.7,
        lexical_weight: float = 0.3
    ) -> list[dict]:
        # Sémantické vyhľadávanie
        query_emb = self.client.embeddings.create(
            input=query, model=self.model
        ).data[0].embedding
        sem_scores = self.embeddings @ np.array(query_emb)
        sem_ranking = [
            (i, float(sem_scores[i]))
            for i in np.argsort(sem_scores)[::-1]
        ]

        # Lexikálne vyhľadávanie
        query_tokens = tokenize(query)
        lex_scores = self.bm25.get_scores(query_tokens)
        lex_ranking = [
            (i, float(lex_scores[i]))
            for i in np.argsort(lex_scores)[::-1]
        ]

        # RRF Fusion
        fused = reciprocal_rank_fusion(
            [sem_ranking, lex_ranking]
        )

        return [
            {
                "text": self.documents[doc_id],
                "rrf_score": score,
                "sem_score": float(sem_scores[doc_id]),
                "lex_score": float(lex_scores[doc_id]),
            }
            for doc_id, score in fused[:k]
        ]

# Použitie
engine = HybridSearch()
engine.index([
    "Comment résoudre l'erreur 503 dans nginx",
    "Timeout et configuration du reverse proxy",
    "Guide d'installation nginx sur Ubuntu",
    "Diagnostiquer les problèmes de serveur web",
])

results = engine.search("erreur 503 nginx")
for r in results:
    print(f"RRF: {r['rrf_score']:.4f} | "
          f"Sem: {r['sem_score']:.3f} | "
          f"Lex: {r['lex_score']:.3f} | "
          f"{r['text']}")

Na tomto korpuse so štyrmi dokumentmi dominuje článok „nginx error 503“ v lexikálnom poradí, zatiaľ čo „web server issues“ dominuje v tom sémantickom; fúzia dostane obe do top trojky, čo by ani jedna metóda sama nedokázala.

Natívne hybridné vyhľadávanie vo Weaviate

Ak už používaš Weaviate, nemusíš toto všetko písať: databáza integruje fúziu a vystavuje ju v jednej otázke s parametrom alpha, ktorý vyvažuje oba enginy – 0 pre čisto lexikálne, 1 pre čisto sémantické.

import weaviate

wclient = weaviate.connect_to_local()
collection = wclient.collections.get("Document")

# Natívne hybridné vyhľadávanie
results = collection.query.hybrid(
    query="erreur 503 nginx",
    alpha=0.7,  # 0 = pure lexical, 1 = pure semantic
    limit=5
)

for obj in results.objects:
    print(f"[{obj.metadata.score:.3f}] {obj.properties['texte']}")

Hodnota alpha 0,7 je rozumným východiskovým bodom, nie je však univerzálna: korpus bohatý na technické referencie a chybové kódy profituje z poklesu smerom k 0,5, zatiaľ čo znalostná báza napísaná prirodzeným jazykom zvládne 0,8. Tento posúvač ladíš iba s evaluačnou množinou pred očami – to je presne téma nasledujúcej lekcie.

Kľúčové poznatky

  • Hybridné vyhľadávanie kombinuje sémantiku (význam) a lexiku (presné slová)
  • Reciprocal Rank Fusion (RRF) efektívne spája poradia
  • Parameter alpha riadi vyváženosť medzi oboma prístupmi
  • Weaviate ponúka hybridné vyhľadávanie natívne