Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Iskanje hibridnega tipa (semantično + leksikalno)

Lekcija 9 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Cilji
  2. Težava: noben pristop ni popoln
  3. Leksikalno iskanje z BM25
  4. Recipročna združitev rangov (RRF)
  5. Celoten hibridni potek
  6. Avtohtono hibridno iskanje v Weaviate
  7. Ključne ugotovitve

Cilji

  • Razumeš, zakaj je kombinacija semantičnega in leksikalnega iskanja ključna
  • Implementiraš hibridno iskanje z uporabo recipročne združitve rangov (Reciprocal Rank Fusion)
  • Uporabiš hibridno iskanje v vektorskih bazah podatkov

Težava: noben pristop ni popoln

Semantično iskanje odlično obravnava sopomenke, lahko pa spregleda natančne tehnične izraze; leksikalno iskanje deluje ravno obratno. Razmisli o poizvedbi skrbnika sistema „napaka nginx 503” in opazuj, kako se obnašata oba mehanizma glede na bazo tehnične dokumentacije.

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

Semantično iskanje razume, da gre za incident na strežniku, in prikaže splošne članke, vendar mu številka 503 uide: za model vgradnje sta 503 in 504 le dve trimesečni števili, semantično blizu, čeprav označujeta različne izpade. Leksikalno iskanje pridobi točno kodo, a spregleda članek o časovnih omejitvah obratnega posrednika (reverse proxy timeout), ki pogosto opisuje glavni vzrok. Nobena metoda sama po sebi ne vrne prave strani z rezultati; to stori šele njuna unija.

Leksikalno iskanje z BM25

BM25 je standardni algoritem za iskanje po ključnih besedah. Vsakemu izrazu dodeli težo glede na njegovo redkost v korpusu in pogostost v dokumentu, kar naravno izpostavi diskriminativne izraze, kot sta „503” ali „nginx”. Vendar mu moraš predložiti čiste žetone: funkcija za tokenizacijo pretvori besedilo v male črke, izvleče besede in odstrani slovenske stop besede, ki ne prispevajo signala relevantnosti.

from rank_bm25 import BM25Okapi
import re

def tokenize(text: str) -> list[str]:
    """Simple tokenization for French."""
    text = text.lower()
    tokens = re.findall(r"\b\w+\b", text)
    # Remove common stop words
    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",
]

# Index with BM25
tokenized_corpus = [tokenize(doc) for doc in documents]
bm25 = BM25Okapi(tokenized_corpus)

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

Recipročna združitev rangov (RRF)

Zdaj moraš združiti obe razvrstitvi, kar je težje, kot je videti na prvi pogled: kosinusna ocena se giblje med 0 in 1, medtem ko ocena BM25 nima zgornje meje. Če bi ju neposredno sešteli, bi BM25 popolnoma preglasil semantični signal. RRF se temu izogne tako, da ignorira surove ocene in ohrani le range: vsak dokument prejme vrednost 1 / (k + rank) v vsakem seznamu, te prispevke pa sešteješ. Dokument, ki se dobro uvršča povsod, tako premaga dokument, ki izstopa le na enem seznamu.

def reciprocal_rank_fusion(
    result_lists: list[list[tuple[int, float]]],
    k: int = 60
) -> list[tuple[int, float]]:
    """Fuses multiple result lists using RRF.

    Args:
        result_lists: list of lists of (doc_id, score)
        k: RRF constant (60 is standard)
    """
    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)

    # Sort by score descending
    return sorted(
        fused_scores.items(),
        key=lambda x: x[1],
        reverse=True
    )

Konstanta k, ki se po literaturi običajno nastavi na 60, ublaži razliko med najboljšimi mesti: brez nje bi imel prvi rang dvakratno težo drugega, zaradi česar bi bila združitev preobčutljiva na manjše razlike v razvrstitvi.

Celoten hibridni potek

Spodnji razred vzporedno vzdržuje oba indeksa nad istim korpusom, za vsako poizvedbo izvede obe vrsti iskanja in združi razvrstitve. Vrne tudi posamezne ocene – kar je dragocena podrobnost med uglaševanjem, saj primerjava pokaže, kateri mehanizem je prispeval določen rezultat.

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

        # Semantic 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]:
        # Semantic search
        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]
        ]

        # Lexical search
        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]
        ]

# Usage
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 tem korpusu štirih dokumentov članek „napaka nginx 503” dominira v leksikalni razvrstitvi, medtem ko „težave s spletnim strežnikom” dominira v semantični; združitev pripelje oba med prve tri, česar nobena metoda sama ne bi dosegla.

Avtohtono hibridno iskanje v Weaviate

Če že uporabljaš Weaviate, vsega tega ni treba pisati ročno: baza podatkov integrira združevanje in ga izpostavi v enem samem poizvedbi s parametrom alpha, ki uravnava ravnovesje med obema mehanizmoma – 0 za čisto leksikalno, 1 za čisto semantično iskanje.

import weaviate

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

# Native hybrid search
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']}")

Vrednost alpha 0,7 je razumen začetni punkt, vendar ni univerzalen: korpus, bogat s tehničnimi referencami in kodami napak, ima korist od znižanja proti 0,5, medtem ko zbirka znanja, napisana v preprostem jeziku, prenese 0,8. Ta drsnik uglašaj le ob evalvacijskem naboru pred seboj – kar je ravno tema naslednje lekcije.

Ključne ugotovitve

  • Hibridno iskanje združuje semantično (pomen) in leksikalno (točne besede)
  • Recipročna združitev rangov (RRF) učinkovito združi razvrstitve
  • Parameter alpha nadzira ravnovesje med obema pristopoma
  • Weaviate ponuja hibridno iskanje avtohtono