Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Hybrid sökning (semantisk + lexikal)

Lektion 9 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Mål
  2. Problemet: ingen enskild metod är perfekt
  3. Lexikal sökning med BM25
  4. Reciprocal Rank Fusion (RRF)
  5. Kompletta hybridpipelinen
  6. Inbyggd hybrid sökning i Weaviate
  7. Viktiga punkter

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 alpha styr balansen mellan de två metoderna
  • Weaviate erbjuder hybrid sökning inbyggt