Căutare hibridă (semantică + lexicală)
Pe această pagină
Obiective
- Înțelegeți de ce combinarea căutării semantice cu cea lexicală este importantă
- Implementați căutarea hibridă folosind Reciprocal Rank Fusion (Fuziunea Rangului Reciproc)
- Utilizați căutarea hibridă în bazele de date vectoriale
Problema: nicio abordare unică nu este perfectă
Căutarea semantică excelează în gestionarea sinonimelor, dar poate rata termenii tehnici preciși; căutarea lexicală face exact invers. Luați în considerare interogarea unui administrator de sistem, „nginx error 503“, și observați cum se comportă ambele motoare față de o bază de documentație tehnică.
# 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 ✅
Căutarea semantică înțelege că aceasta se referă la un incident de server și afișează articole generale, dar numărul 503 îi scapă: pentru un model de embedding, 503 și 504 sunt doar două numere de trei cifre, semantic apropiate, deși denotă întreruperi diferite. Căutarea lexicală recuperează codul exact, dar ratează articolul despre timeout-urile proxy-ului invers, care descrie adesea cauza principală. Nicio metodă utilizată singură nu returnează pagina cu rezultatele corecte; uniunea lor da.
Căutarea lexicală cu BM25
BM25 este algoritmul standard pentru căutarea după cuvinte cheie. Acesta ponderează fiecare termen în funcție de raritatea sa în corpus și de frecvența sa în document, scoțând natural în evidență termenii discriminatorii precum „503“ sau „nginx“. Totuși, trebuie să îi furnizați tokeni curați: funcția de tokenizare transformă textul în litere mici, extrage cuvintele și elimină cuvintele de stopare (stop words) care nu aduc niciun semnal de relevanță.
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)
Acum trebuie să combinați cele două clasificări, ceea ce este mai complicat decât pare: un scor cosine se situează între 0 și 1, în timp ce un scor BM25 nu are o limită superioară. Adunarea lor directă ar permite ca BM25 să copleșească semnalul semantic. RRF ocolește această problemă ignorând scorurile brute și păstrând doar rangurile: fiecare document primește 1 / (k + rank) în fiecare listă, iar dumneavoastră însumați aceste contribuții. Astfel, un document care se clasează bine peste tot va învinge un document care excelează doar într-o singură listă.
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
)
Constanta k, setată convențional la 60 conform literaturii de specialitate, atenuează decalajul dintre primele poziții: fără ea, primul rang ar cântări de două ori mai mult decât al doilea, făcând fuziunea prea sensibilă la diferențe minore de clasificare.
Pipeline hibrid complet
Clasa de mai jos menține ambii indici în paralel pe același corpus, rulează ambele căutări pentru fiecare interogare și fuzionează clasificările. De asemenea, returnează scorurile individuale – un detaliu valoros în timpul ajustării, deoarece compararea lor arată care motor a susținut un anumit 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']}")
Pe acest corpus de patru documente, articolul „nginx error 503“ domină clasificarea lexicală, în timp ce „web server issues“ domină cea semantică; fuziunea aduce ambele în top trei, lucru pe care nicio metodă nu l-ar realiza singură.
Căutarea hibridă nativă în Weaviate
Dacă utilizați deja Weaviate, nu trebuie să scrieți toate acestea: baza de date integrează fuziunea și o expune într-o singură interogare, cu un parametru alpha care echilibrează cele două motoare – 0 pentru pur lexical, 1 pentru pur semantic.
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']}")
Un alpha de 0,7 este un punct de plecare rezonabil, dar nu este universal: un corpus bogat în referințe tehnice și coduri de eroare beneficiază de o coborâre către 0,5, în timp ce o bază de cunoștințe scrisă în limbaj natural poate gestiona 0,8. Ajustați acest cursor doar având în față un set de evaluare – acesta este chiar subiectul lecției următoare.
Puncte cheie
- Căutarea hibridă combină aspectul semantic (sens) cu cel lexical (cuvinte exacte)
- Reciprocal Rank Fusion (RRF) fuzionează eficient clasificările
- Parametrul
alphacontrolează echilibrul dintre cele două abordări - Weaviate oferă căutare hibridă în mod nativ