Hybrid sökning (semantisk + lexikal)
På denna sida
Mål
- Förstå varför det är viktigt att kombinera semantisk och lexikal sökning
- Implementera hybrid sökning med Reciprocal Rank Fusion
- Använda hybrid sökning i vektordatabaser
Problemet: ingen enskild metod är perfekt
Semantisk sökning är bäst på att hantera synonymer men kan missa exakta tekniska termer; lexikal sökning gör tvärtom. Tänk dig en systemadministratörs fråga, “nginx error 503”, och observera hur båda motorerna beter sig mot en bas 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ökning förstår att detta rör en serverincident och lyfter fram generella artiklar, men talet 503 undgår den: för en inbäddningsmodell är 503 och 504 bara två tresiffriga tal, semantiskt nära varandra även om de betecknar olika driftstörningar. Lexikal sökning hämtar den exakta koden men missar artikeln om timeout för reverse proxy, som ofta beskriver grundorsaken. Ingen av metoderna ensam returnerar rätt resultatsida; deras förening gör det.
Lexikal sökning med BM25
BM25 är standardalgoritmen för nyckelordssökning. Den viktar varje term baserat på dess sällsynthet i korpusen och dess frekvens i dokumentet, vilket naturligt lyfter fram diskriminerande termer som “503” eller “nginx”. Du måste dock mata den med rena token: tokeniseringsfunktionen gör texten till gemener, extraherar ord och tar bort franska stoppord, som inte bidrar med någon 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 måste du kombinera de två rankinglistorna, vilket är klurigare än det ser ut: en cosinusscore ligger mellan 0 och 1, medan en BM25-score saknar övre gräns. Att addera dem direkt skulle låta BM25 kväva den semantiska signalen. RRF kringgår detta genom att ignorera råa poäng och bara behålla rankningar: varje dokument får 1 / (k + rank) i varje lista, och du summerar dessa bidrag. Ett dokument som rankas högt överallt slår därmed ett dokument som bara excellerar i en lista.
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 konventionellt sätts till 60 baserat på litteraturen, dämpar gapet mellan toppositionerna: utan den skulle första rankningen väga dubbelt så mycket som den andra, vilket gör fusionen för känslig för mindre skillnader i rankningen.
Kompletta hybridpipelinen
Klassen nedan underhåller båda indexen parallellt över samma korpus, kör båda sökningarna för varje fråga och fusionerar rankningarna. Den returnerar också individuella poäng – en värdefull detalj vid finjustering, eftersom jämförelsen visar vilken motor som bar upp ett givet 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å denna korpus med fyra dokument dominerar artikeln “nginx error 503” den lexikala rankningen, medan “web server issues” dominerar den semantiska; fusionen får båda att hamna bland de tre bästa, något ingen av metoderna skulle uppnå ensam.
Inbyggd hybrid sökning i Weaviate
Om du redan använder Weaviate behöver du inte skriva allt detta: databasen integrerar fusion och exponerar den i en enda fråga, med en parameter alpha som balanserar de två motorerna – 0 för ren lexikal sökning, 1 för ren semantisk sökning.
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']}")
Ett alpha på 0,7 är en rimlig startpunkt, men det är inte universellt: en korpus rik på tekniska referenser och felkoder gynnas av att sänkas mot 0,5, medan en kunskapsbas skriven på enkelt språk kan hantera 0,8. Finjustera bara denna reglage med en utvärderingsuppsättning framför dig – det är precis ämnet för nästa lektion.
Viktiga punkter
- Hybrid sökning kombinerar semantisk (betydelse) och lexikal (exakta ord)
- Reciprocal Rank Fusion (RRF) slår samman rankningar effektivt
- Parametern
alphastyr balansen mellan de två metoderna - Weaviate erbjuder hybrid sökning inbyggt