Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Tfittxija ibrida (semantika + lessikali)

Lezzjoni 9 / 22 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Għanijiet
  2. Il-problema: l-ebda approċċ wieħed mhu perfett
  3. Tfittxija lessikali b’BM25
  4. Reciprocal Rank Fusion (RRF)
  5. Pipeline ibrida sħiħa
  6. Tfittxija ibrida nattiva f’Weaviate’
  7. Punti Ewlenin

Għanijiet

  • Fehem għaliex tgħaqqad it-tfittxija semantika u dik lessikali huwa importanti
  • Implimenta t-tfittxija ibrida bl-użu ta’ Reciprocal Rank Fusion
  • Uża t-tfittxija ibrida f’databases vettorjali

Il-problema: l-ebda approċċ wieħed mhu perfett

It-tfittxija semantika taqbel ħafna fit-trattament tas-sinonimi iżda tista’ titlef termini tekniċi preċiżi; it-tfittxija lessikali tagħmel l-eżatt oppost. Ħu bħala eżempju mistoqsija ta’ amministratur tas-sistema, “nginx error 503”, u ara kif jiġu mġieba ż-żewġ magni kontra bażi ta’ dokumentazzjoni teknika.

# 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 ✅

It-tfittxija semantika tifhem li dan jirreferi għal inċident tas-server u toħroġ artikli ġenerali, iżda n-numru 503 jaħrabilha: għal mudell ta’ embedding, 503 u 504 huma biss żewġ numri ta’ tliet ċifri, semantikament qrib xulxin għalkemm jindikaw ħsarat differenti. It-tfittxija lessikali tirrikupra l-kodiċi eżatt iżda titlef l-artiklu dwar it-timeouts tal-proxy invers, li spiss jiddeskrivi l-kawża primarja. L-ebda metodu waħdu ma jirritorna l-paġna tar-riżultati t-tajba; l-unjoni tagħhom iva.

Tfittxija lessikali b’BM25

BM25 huwa l-algoritmu standard għat-tfittxija b’kliem ewlieni. Jiżen kull terminu abbażi tar-rarità tiegħu fil-corpus u l-frekwenza tiegħu fid-dokument, u b’mod naturali joħroġ termini diskriminatorji bħal “503” jew “nginx”. Madankollu, trid tgħaddilu tokens nodfa: il-funzjoni ta’ tokenizzazzjoni tbiddel it-test għal ittri żgħar, testraġġi l-kliem, u tneħħi stop words Franċiżi, li ma jżidux sinjal ta’ rilevanza.

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)

Issa għandek bżonn tgħaqqad iż-żewġ klassifikazzjonijiet, li huwa aktar diffiċli milli jidher: punteġġ cosine jinsab bejn 0 u 1, filwaqt li punteġġ BM25 m’għandux limitu massimu. Li żżidhom direttament iħalli lil BM25 jegħleb is-sinjal semantiku. RRF jevita dan billi jinjora l-punteġġi raw u jżomm biss il-klassifikazzjonijiet: kull dokument jirċievi 1 / (k + rank) f’kull lista, u inti tgħodd dawn il-kontribuzzjonijiet. Dokument li jikklassifika tajjeb kullimkien hekk jegħleb dokument li jeċċella f’lista waħda biss.

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
    )

Il-kostanti k, konvenzjonalment issettjata għal 60 abbażi tal-letteratura, tnaqqas id-differenza bejn il-pożizzjonijiet ta’ quddiem: mingħajrha, l-ewwel klassifikazzjoni tkun tiżen darbtejn aktar mit-tieni, u tagħmel il-fużjoni wisq sensittiva għal differenzi żgħar fil-klassifikazzjoni.

Pipeline ibrida sħiħa

Il-klassi hawn taħt iżżomm iż-żewġ indiċijiet paralleli fuq l-istess corpus, tħaddem iż-żewġ tfittxijiet fuq kull mistoqsija, u tgħaqqad il-klassifikazzjonijiet. Tirritorna wkoll punteġġi individwali—detall prezzjuż waqt is-sintonizzazzjoni, peress li tqabbilhom juri liema magna ġarrbet riżultat partikolari.

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']}")

Fuq dan il-corpus ta’ erba’ dokumenti, l-artiklu “nginx error 503” jiddomina l-klassifikazzjoni lessikali, filwaqt li “web server issues” jiddomina dik semantika; il-fużjoni ġġib iż-żewġ artikli fit-tliet ta’ fuq, xi ħaġa li l-ebda metodu waħdu ma jkun jista’ jikseb.

Tfittxija ibrida nattiva f’Weaviate’

Jekk diġà tuża Weaviate, m’għandekx bżonn tikteb dan kollu: id-database tintegra l-fużjoni u tesponiha f’mistoqsija waħda, b’parametru alpha li jibbilanċja ż-żewġ magni—0 għal lessikali pur, 1 għal semantiku pur.

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']}")

Alpha ta’ 0.7 huwa punt tat-tluq raġonevoli, iżda mhuwiex universali: corpus rikk f’referenzi tekniċi u kodiċijiet ta’ żball jibbenefika minn tnaqqis lejn 0.5, filwaqt li bażi tal-għarfien miktuba b’lingwaġġ sempliċi tista’ tittratta 0.8. Issintonizza dan is-slider biss meta jkollok sett ta’ evalwazzjoni quddiemek—dan huwa preċiżament is-suġġett tal-lezzjoni li jmiss.

Punti Ewlenin

  • It-tfittxija ibrida tgħaqqad is-semantika (tifsira) u l-lessikali (kliem eżatt)
  • Reciprocal Rank Fusion (RRF) tgħaqqad il-klassifikazzjonijiet b’mod effettiv
  • Il-parametru alpha jikkontrolla l-bilanċ bejn iż-żewġ approċċi
  • Weaviate joffri tfittxija ibrida b’mod nattiv