Meklēšana hibrīdrežīmā (semantiskā + leksikālā)
Šajā lapā
Mērķi
- Saprast, kāpēc ir svarīgi apvienot semantisko un leksikālo meklēšanu
- Implementēt hibrīdo meklēšanu, izmantojot Reciprocal Rank Fusion (RRF)
- Izmantot hibrīdo meklēšanu vektoru datubāzēs
Problēma: neviena pieeja nav ideāla
Semantiskā meklēšana lieliski tiek galā ar sinonīmiem, bet var palaist garām precīzus tehniskos terminus; leksikālā meklēšana dara tieši pretējo. Apskatīsim sistēmas administratora vaicājumu „nginx error 503” un novērosim, kā abi dzinēji uzvedas, strādājot ar tehniskās dokumentācijas bāzi.
# 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 ✅
Semantiskā meklēšana saprot, ka tas attiecas uz servera incidentu, un piedāvā vispārīgus rakstus, taču skaitlis 503 tai paslīd garām: iegulšanas (embedding) modelim 503 un 504 ir vienkārši divi trīsciparu skaitļi, kas semantiski ir tuvu, lai gan tie apzīmē dažādus pārtraukumus. Leksikālā meklēšana atrod precīzu kodu, bet palaiž garām rakstu par reversā starpnieka (reverse proxy) noilgumiem, kas bieži vien apraksta pamatcēloni. Neviena metode vienatnē neatgriež pareizo rezultātu lapu; to dara tikai abu apvienojums.
Leksikālā meklēšana ar BM25
BM25 ir standarta algoritms atslēgvārdu meklēšanai. Tas nosver katru terminu, balstoties uz tā retumu korpusā un biežumu dokumentā, dabiski izceļot diskriminējošus terminus, piemēram, „503” vai „nginx”. Tomēr tam ir jāpadod tīri tokeni: tokenizācijas funkcija pārvērš tekstu mazajos burtos, izgūst vārdus un noņem franču valodas stopvārdus, kas nesniedz nekādu nozīmīguma signālu.
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]}")
Reciprocal Rank Fusion (RRF)
Tagad tev ir jāapvieno abi rangi, kas ir sarežģītāk, nekā izskatās: kosinusa rezultāts ir robežās no 0 līdz 1, savukārt BM25 rezultātam nav augšējās robežas. To tieša saskaitīšana ļautu BM25 pilnībā nomākt semantisko signālu. RRF apej šo problēmu, ignorējot neapstrādātos rezultātus un saglabājot tikai rangus: katrs dokuments katrā sarakstā saņem vērtību 1 / (k + rank), un tu šīs vērtības summēji. Dokuments, kas visur ir augstu rangā, tādējādi pārspēj dokumentu, kas izceļas tikai vienā sarakstā.
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
)
Konstante k, ko literatūrā parasti iestata uz 60, samazina atstarpi starp augstākajām pozīcijām: bez tās pirmais rangs svērtu divreiz vairāk nekā otrais, padarot sapludināšanu pārāk jutīgu pret nelielām rangu atšķirībām.
Pilna hibrīdā cauruļvada implementācija
Zemāk esošā klase uztur abus indeksus paralēli vienam un tam pašam korpusam, katram vaicājumam veic abas meklēšanas un sapludina rangus. Tā arī atgriež individuālos rezultātus – vērtīga detaļa pielāgošanas laikā, jo to salīdzināšana parāda, kurš dzinējs ir nesis konkrētu rezultātu.
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']}")
Šajā četru dokumentu korpusā raksts „nginx error 503” dominē leksikālajā rangā, savukārt „web server issues” dominē semantiskajā; sapludināšana abus ievieto pirmajos trīs rezultātos, ko neviena metode vienatnē nespētu sasniegt.
Natīvā hibrīdā meklēšana vietnē Weaviate
Ja jau izmanto Weaviate, tev nav jāraksta viss šis kods: datubāze integrē sapludināšanu un eksponē to vienā vaicājumā, izmantojot parametru alpha, kas līdzsvaro abus dzinējus – 0 tīrai leksikālai un 1 tīrai semantiskai meklēšanai.
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']}")
alpha vērtība 0,7 ir saprātīgs sākumpunkts, taču tā nav universāla: korpusam, kas bagāts ar tehniskām atsaucēm un kļūdu kodiem, ir lietderīgi samazināt vērtību līdz 0,5, savukārt zināšanu bāze, kas rakstīta vienkāršā valodā, var izturēt 0,8. Pielāgo šo slīdni tikai tad, ja tev priekšā ir novērtēšanas kopa – tas ir tieši nākamās nodarbības temats.
Galvenās atziņas
- Hibrīdā meklēšana apvieno semantisko (nozīme) un leksikālo (precīzi vārdi)
- Reciprocal Rank Fusion (RRF) efektīvi apvieno rangus
- Parametrs
alphakontrolē līdzsvaru starp abām pieejām - Weaviate piedāvā hibrīdo meklēšanu natīvā režīmā