Pretraživanje hibridnog tipa (semantičko + leksičko)
Na ovoj stranici
Ciljevi
- Razumjeti zašto je kombiniranje semantičkog i leksičkog pretraživanja ključno
- Implementirati hibridno pretraživanje koristeći Reciprocal Rank Fusion (RRF)
- Koristiti hibridno pretraživanje u vektorskim bazama podataka
Problem: nijedan pristup nije savršen
Semantičko pretraživanje izvrsno obrađuje sinonime, ali može promašiti precizne tehničke pojmove; leksičko pretraživanje radi točno suprotno. Razmotri upit administratora sustava „nginx error 503“ i promatraj kako se oba mehanizma ponašaju nad bazom tehničke 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čko pretraživanje shvaća da se radi o incidentu na poslužitelju i izdvaja općenite članke, no broj 503 mu izmiče: za model ugradnje (embedding), 503 i 504 su samo dva troznamenkasta broja, semantički bliska iako označavaju različite kvarove. Leksičko pretraživanje dohvaća točan kod, ali promašuje članak o isteku vremena (timeout) reverse proxyja, koji često opisuje uzrok problema. Ni jedna metoda sama ne vraća ispravnu stranicu s rezultatima; to čini njihova unija.
Leksičko pretraživanje s BM25
BM25 je standardni algoritam za pretraživanje ključnih riječi. Vaga svaki pojam na temelju njegove rijetkosti u korpusu i učestalosti u dokumentu, prirodno izdvajajući diskriminirajuće pojmove poput „503“ ili „nginx“. Međutim, moraš mu dostaviti čiste tokene: funkcija tokenizacije pretvara tekst u mala slova, izdvaja riječi i uklanja hrvatske stop-riječi koje ne donose signal relevantnosti.
from rank_bm25 import BM25Okapi
import re
def tokenize(text: str) -> list[str]:
"""Jednostavna tokenizacija za hrvatski."""
text = text.lower()
tokens = re.findall(r"\b\w+\b", text)
# Ukloni česte stop-riječi
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",
]
# Indeksiraj s BM25
tokenized_corpus = [tokenize(doc) for doc in documents]
bm25 = BM25Okapi(tokenized_corpus)
# Pretraži
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)
Sada moraš kombinirati ta dva rangiranja, što je složenije nego što izgleda: kosinusna ocjena kreće se između 0 i 1, dok BM25 ocjena nema gornju granicu. Njihovo izravno zbrajanje omogućilo bi BM25 da potpuno nadjača semantički signal. RRF zaobilazi ovaj problem ignoriranjem sirovih ocjena i zadržavanjem samo rangova: svaki dokument dobiva 1 / (k + rank) u svakom popisu, a ti zbrajaš te doprinose. Dokument koji se dobro rangira svugdje tako pobjeđuje dokument koji odlično stoji samo u jednom popisu.
def reciprocal_rank_fusion(
result_lists: list[list[tuple[int, float]]],
k: int = 60
) -> list[tuple[int, float]]:
"""Spaja više popis rezultata koristeći RRF.
Args:
result_lists: popis popisa od (doc_id, score)
k: RRF konstanta (60 je 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)
# Sortiraj po ocjeni silazno
return sorted(
fused_scores.items(),
key=lambda x: x[1],
reverse=True
)
Konstanta k, konvencionalno postavljena na 60 na temelju literature, ublažava jaz između vrhunskih pozicija: bez nje, prvi rang bi imao dvostruko veću težinu od drugog, čineći fuziju preosjetljivom na manje razlike u rangiranju.
Potpuni hibridni pipeline
Donja klasa održava oba indeksa paralelno nad istim korpusom, pokreće oba pretraživanja za svaki upit i spaja rangiranja. Također vraća pojedinačne ocjene – vrijedan detalj tijekom ugađanja, jer njihova usporedba pokazuje koji je mehanizam „nosio“ određeni 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
# Semantički indeks
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 indeks
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]:
# Semantičko pretraživanje
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]
]
# Leksičko pretraživanje
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 Fuzija
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]
]
# Upotreba
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 ovom korpusu od četiri dokumenta, članak „nginx error 503“ dominira leksičkim rangiranjem, dok „web server issues“ dominira semantičkim; fuzija dovodi oba u prve tri pozicije, što nijedna metoda sama ne bi postigla.
Izvorno hibridno pretraživanje u Weaviateu
Ako već koristiš Weaviate, ne moraš pisati sve ovo: baza podataka integrira fuziju i izlaže je u jednom upitu, s parametrom alpha koji balansira dva mehanizma – 0 za čisto leksičko, 1 za čisto semantičko.
import weaviate
wclient = weaviate.connect_to_local()
collection = wclient.collections.get("Document")
# Izvorno hibridno pretraživanje
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']}")
Vrijednost alpha od 0.7 razumna je početna točka, ali nije univerzalna: korpus bogat tehničkim referencama i kodovima pogrešaka ima koristi od smanjenja prema 0.5, dok baza znanja napisana jednostavnim jezikom može podnijeti 0.8. Ovaj klizač ugađaj isključivo uz evaluacijski skup ispred sebe – to je upravo tema sljedeće lekcije.
Ključne točke
- Hibridno pretraživanje kombinira semantičko (značenje) i leksičko (točne riječi)
- Reciprocal Rank Fusion (RRF) učinkovito spaja rangiranja
- Parametar
alphakontrolira ravnotežu između dva pristupa - Weaviate nudi hibridno pretraživanje izvorno