Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Hybrid søgning (semantisk + leksikalsk)

Lektion 9 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Mål
  2. Problemet: Ingen enkelt tilgang er perfekt
  3. Leksikalsk søgning med BM25
  4. Reciprocal Rank Fusion (RRF)
  5. Komplet hybrid pipeline
  6. Nativer hybrid søgning i Weaviate
  7. Vigtige pointer

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 alpha styrer balancen mellem de to tilgange
  • Weaviate tilbyder hybrid søgning nativt