Hybrid søgning (semantisk + leksikalsk)
På denne side
Mål
- Forstå hvorfor det er vigtigt at kombinere semantisk og leksikalsk søgning
- Implementere hybrid søgning ved hjælp af Reciprocal Rank Fusion
- Anvende hybrid søgning i vektordatabaser
Problemet: Ingen enkelt tilgang er perfekt
Semantisk søgning er fremragende til at håndtere synonymer, men kan overse præcise tekniske begreber; leksikalsk søgning gør præcis det modsatte. Overvej en systemadministrators forespørgsel, „nginx error 503”, og observer hvordan begge motorer opfører sig mod en base med teknisk dokumentation.
# 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 søgning forstår, at dette refererer til en serverhændelse, og finder generelle artikler frem, men tallet 503 undgår den: for en indlejringsmodel er 503 og 504 blot to trecifrede tal, der er semantisk tæt på hinanden, selvom de betegner forskellige nedbrud. Leksikalsk søgning henter den præcise kode, men overser artiklen om reverse proxy-timeouts, som ofte beskriver årsagen. Ingen af metoderne alene returnerer den rigtige resultatside; deres forening gør.
Leksikalsk søgning med BM25
BM25 er standardalgoritmen til søgning efter nøgleord. Den vægter hvert led baseret på dets sjældenhed i korpussen og dets hyppighed i dokumentet, hvilket naturligt bringer diskriminerende led som „503” eller „nginx” frem. Du skal dog fodre den med rene tokens: tokeniseringsfunktionen gør tekst til små bogstaver, udtrækker ord og fjerner franske stop-ord, som ikke tilfører noget relevanssignal.
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)
Nu skal du kombinere de to rangeringer, hvilket er sværere end det ser ud: en cosinus-score ligger mellem 0 og 1, mens en BM25-score ikke har nogen øvre grænse. Hvis du lægger dem direkte sammen, vil BM25 overdøve det semantiske signal. RRF omgår dette ved at ignorere rå scores og kun beholde rangeringer: hvert dokument modtager 1 / (k + rank) i hver liste, og du summerer disse bidrag. Et dokument, der rangerer godt overalt, slår dermed et dokument, der kun excellerer i én liste.
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
)
Konstanten k, som konventionelt sættes til 60 baseret på litteraturen, dæmper kløften mellem topplaceringerne: uden den ville den første plads veje dobbelt så meget som den anden, hvilket gør fusionen for følsom over for mindre rangeringsforskelle.
Komplet hybrid pipeline
Klassen nedenfor vedligeholder begge indekser parallelt over det samme korpus, kører begge søgninger på hver forespørgsel og fusionerer rangeringerne. Den returnerer også individuelle scores – en værdifuld detalje under finjustering, da sammenligning af dem viser, hvilken motor der bar et givent resultat.
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']}")
På dette korpus med fire dokumenter dominerer artiklen „nginx error 503” den leksikalske rangering, mens „web server issues” dominerer den semantiske; fusionen bringer begge ind i top tre, noget ingen af metoderne ville opnå alene.
Nativer hybrid søgning i Weaviate
Hvis du allerede bruger Weaviate, behøver du ikke skrive alt dette: databasen integrerer fusion og eksponerer den i en enkelt forespørgsel med en alpha-parameter, der balancerer de to motorer – 0 for ren leksikalsk, 1 for ren semantisk.
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']}")
En alpha på 0,7 er et rimeligt udgangspunkt, men det er ikke universelt: et korpus rigt på tekniske referencer og fejlkoder har fordel af at falde mod 0,5, mens en vidensbase skrevet i almindeligt sprog kan håndtere 0,8. Finjuster kun denne skyder med et evalueringssæt foran dig – det er netop emnet for næste lektion.
Vigtige pointer
- Hybrid søgning kombinerer semantisk (betydning) og leksikalsk (nøjagtige ord)
- Reciprocal Rank Fusion (RRF) fletter rangeringer effektivt
- Parameteren
alphastyrer balancen mellem de to tilgange - Weaviate tilbyder hybrid søgning nativt