Hybridinė paieška (semantinė + leksinė)
Šiame puslapyje
Tikslai
- Suprasti, kodėl svarbu derinti semantinę ir leksinę paiešką
- Įgyvendinti hibridinę paiešką naudojant abipusį rangų suliejimą (Reciprocal Rank Fusion)
- Naudoti hibridinę paiešką vektorių duomenų bazėse
Problema: joks vienas metodas nėra tobulas
Semantinė paieška puikiai tvarkosi su sinonimais, tačiau gali praleisti tikslius techninius terminus; leksinė paieška elgiasi visiškai priešingai. Įsivaizduok sistemos administratoriaus užklausą „nginx error 503“ ir stebėk, kaip abu varikliai elgiasi techninės dokumentacijos bazėje.
# 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 ✅
Semantinė paieška supranta, kad tai susiję su serverio incidentu, ir pateikia bendro pobūdžio straipsnius, tačiau skaičius 503 jai išsprūsta: įterpimo modeliui 503 ir 504 yra tiesiog du triženkliai skaičiai, semantiškai artimi, nors ir reiškiantys skirtingus sutrikimus. Leksinė paieška atkuria tikslų kodą, bet praleidžia straipsnį apie atvirkštinio proxy serverio laiko limitus, kuriame dažnai aprašoma pagrindinė priežastis. Nei vienas metodas atskirai negrąžina tinkamų rezultatų puslapio; tai padaro jų derinys.
Leksinė paieška su BM25
BM25 yra standartinis raktažodžių paieškos algoritmas. Jis kiekvienam terminui suteikia svorį pagal jo retumą korpuse ir dažnumą dokumente, taip natūraliai iškeliant diskriminuojančius terminus, tokius kaip „503“ arba „nginx“. Tačiau turi jam pateikti švarius tokenus: tokenizavimo funkcija tekstą paverčia mažosiomis raidėmis, išskiria žodžius ir pašalina lietuviškus stop žodžius, kurie nesuteikia jokios aktualumo informacijos.
from rank_bm25 import BM25Okapi
import re
def tokenize(text: str) -> list[str]:
"""Paprastas tokenizavimas lietuvių kalbai."""
text = text.lower()
tokens = re.findall(r"\b\w+\b", text)
# Pašalinti dažnus stop žodžius
stop_words = {"ir", "ar", "bet", "kad", "jei", "kai", "kur", "kas",
"su", "be", "nuo", "iki", "dėl", "apie", "po", "prie",
"yra", "būti", "tai", "jau", "dar", "tik", "net", "gi"}
return [t for t in tokens if t not in stop_words]
documents = [
"Kaip išspręsti nginx klaidą 503",
"Atvirkštinio proxy konfigūravimas su laiko limitu",
"Nginx diegimo Ubuntu vadovas",
"Prancūzų virtuvės pagrindai",
]
# Indeksavimas su BM25
tokenized_corpus = [tokenize(doc) for doc in documents]
bm25 = BM25Okapi(tokenized_corpus)
# Paieška
query_tokens = tokenize("klaida 503 nginx")
bm25_scores = bm25.get_scores(query_tokens)
for i, score in enumerate(bm25_scores):
print(f"BM25 {score:.3f} | {documents[i]}")
Abipusis rangų suliejimas (RRF)
Dabar reikia sujungti abu reitingus, o tai yra sudėtingiau, nei atrodo iš pirmo žvilgsnio: kosinusinis balas yra intervale nuo 0 iki 1, tuo tarpu BM25 balas neturi viršutinės ribos. Jei juos tiesiog sudėtum, BM25 nustelbtų semantinį signalą. RRF šią problemą apeina ignoruodamas žalius balus ir palikdamas tik rangus: kiekvienas dokumentas kiekviename sąraše gauna 1 / (k + rank) reikšmę, o tu šias reikšmes sumuoji. Taigi dokumentas, kuris gerai atrodo visuose sąrašuose, nugalės dokumentą, kuris puikiai pasirodė tik viename sąraše.
def reciprocal_rank_fusion(
result_lists: list[list[tuple[int, float]]],
k: int = 60
) -> list[tuple[int, float]]:
"""Sulieja kelius rezultatų sąrašus naudojant RRF.
Args:
result_lists: sąrašų sąrašas iš (doc_id, score)
k: RRF konstanta (60 yra standartinė)
"""
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)
# Rūšiuoti pagal balą mažėjimo tvarka
return sorted(
fused_scores.items(),
key=lambda x: x[1],
reverse=True
)
Konstanta k, literatūroje paprastai nustatoma į 60, sumažina skirtumą tarp aukščiausių pozicijų: be jos pirmas rangas svertų dvigubai daugiau nei antras, todėl suliejimas taptų per daug jautrus nedideliems reitingų skirtumams.
Pilnas hibridinis konvejeris
Toliau pateikta klasė lygiagrečiai tvarko abu indeksus tame pačiame korpuse, kiekvienai užklausai vykdo abi paieškas ir sulieja reitingus. Ji taip pat grąžina individualius balus – tai vertinga detalė derinant parametrus, nes juos palyginus matyti, kuris variklis lėmė konkretų 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
# Semantinis indeksas
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 indeksas
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]:
# Semantinė paieška
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]
]
# Leksinė paieška
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 suliejimas
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]
]
# Naudojimas
engine = HybridSearch()
engine.index([
"Kaip išspręsti nginx klaidą 503",
"Laiko limitas ir atvirkštinio proxy konfigūravimas",
"Nginx diegimo Ubuntu vadovas",
"Žiniatinklio serverių problemų diagnostika",
])
results = engine.search("klaida 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']}")
Šiame keturių dokumentų korpuse straipsnis „nginx error 503“ dominuoja leksiniame reitinge, o „web server issues“ – semantiniame; suliejimas abu iškelia į pirmąjį trejetuką – to nei vienas metodas atskirai pasiekti negalėtų.
Gimtoji hibridinė paieška Weaviate
Jei jau naudoji Weaviate, tau nereikia rašyti viso šio kodo: duomenų bazė integruoja suliejimą ir pateikia jį vienoje užklausoje su parametru alpha, kuris subalansuoja abu variklius – 0 reiškia gryną leksinę, 1 – gryną semantinę paiešką.
import weaviate
wclient = weaviate.connect_to_local()
collection = wclient.collections.get("Document")
# Gimtoji hibridinė paieška
results = collection.query.hybrid(
query="klaida 503 nginx",
alpha=0.7, # 0 = gryna leksinė, 1 = gryna semantinė
limit=5
)
for obj in results.objects:
print(f"[{obj.metadata.score:.3f}] {obj.properties['texte']}")
alpha reikšmė 0,7 yra geras pradžios taškas, tačiau ji nėra universali: korpusui, kuriame gausu techninių nuorodų ir klaidų kodų, naudinga ją sumažinti iki 0,5, tuo tarpu paprasta kalba parašyta žinių bazė gali atlaikyti 0,8. Derink šį slankiklį tik turėdami prieš akis vertinimo rinkinį – tai bus tiksliai kitos pamokos tema.
Svarbiausi punktai
- Hibridinė paieška derina semantinę (prasmę) ir leksinę (tikslūs žodžiai) paiešką
- Abipusis rangų suliejimas (RRF) efektyviai sujungia reitingus
- Parametras
alphavaldo pusiausvyrą tarp abiejų metodų - Weaviate siūlo hibridinę paiešką kaip gimtąją funkciją