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

Reranking: Titjib Ir-Rilevanza

Lezzjoni 13 / 22 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Għanijiet
  2. Il-Problema tal-Bi-Encoder
  3. Reranking ma’ Cohere
  4. Reranking b’LLM
  5. Integrazzjoni fil-Pipeline ta’ RAG
  6. Impatt tar-Reranking
  7. Punti Ewlenin

Għanijiet

  • Tifhem għaliex ir-reranking itejjeb ir-riżultati
  • Timplimenta reranker bl-użu ta’ cross-encoder
  • Tintegra r-reranking f’pipeline ta’ RAG

Il-Problema tal-Bi-Encoder

It-tfittxija kollha li bnejt sa issa tiddependi fuq bi-encoder: il-mistoqsija u d-dokumenti jiġu kkodifikati separatament, waħedhom, u mqabbla permezz ta’ prodott dot (dot product). Dan huwa dak li jagħmel it-tfittxija istantanja fuq miljuni ta’ biċċiet, peress li l-vetturi tal-korpus ġew ikkalkulati darba għal dejjem. Dan huwa wkoll dak li jagħmilha mhux preċiża, għax il-mudell qatt ma jara l-mistoqsija u d-dokument flimkien: irid jissintetizza kull test f’vettur mingħajr ma jkun jaf x’se jintalab minnu aktar tard.

Cross-encoder, imsejjaħ ukoll reranker, jieħu l-par (mistoqsija, dokument) bħala input u jipproduċi punteġġ ta’ rilevanza ferm aktar fin, għax jaqra ż-żewġ testi flimkien u jista’ jinduna li dokument jitkellem dwar is-suġġett iżda f’sens oppost. Dan il-gwadann għandu prezz: il-mudell irid jipproċessa kull dokument individwalment, li jipprojbixxi l-użu tiegħu fuq il-korpus sħiħ. Is-soluzzjoni hija li tużah fejn ikun kost-effettiv, fuq sett żgħir ta’ kandidati diġà magħżula minn qabel.

Għalhekk il-pipeline fuq żewġ stadji, fejn kull mudell jagħmel dak li jagħmel l-aħjar: dak mgħaġġel jiddejjaq il-qasam, u dak preċiż jagħmel l-għażla finali.

Query → Bi-encoder → Top 50 Candidates → Cross-encoder → Top 5 Results

Reranking ma’ Cohere

Cohere jesponi reranker ta’ prestazzjoni għolja permezz ta’ API, li jevita li tospita mudell. Il-funzjoni li ġejja tgħaqqad iż-żewġ passi: l-ewwel tirrikupra għoxrin kandidat permezz tas-similarità tal-vetturi, imbagħad titlob lil rerank-v3.5 biex iżomm ħamsa biss. Innota l-qasam index_original ippreservat fir-riżultat: ir-reranker jirritorna pożizzjonijiet relattivi għall-lista tal-kandidati, u se jkollok bżonn dan biex terġa’ tmur lura għad-dokument attwali fil-korpus tiegħek.

import cohere
from openai import OpenAI

co = cohere.Client(api_key="your-cohere-key")
openai_client = OpenAI()

def search_and_rerank(
    question: str,
    documents: list[str],
    embeddings_corpus,
    k_retrieval: int = 20,
    k_final: int = 5
) -> list[dict]:
    """Semantic search + reranking."""
    # Step 1: Fast retrieval (bi-encoder)
    query_emb = openai_client.embeddings.create(
        input=question,
        model="text-embedding-3-large"
    ).data[0].embedding

    import numpy as np
    scores = embeddings_corpus @ np.array(query_emb)
    top_indices = np.argsort(scores)[-k_retrieval:][::-1]
    candidates = [documents[i] for i in top_indices]

    # Step 2: Reranking (cross-encoder)
    rerank_response = co.rerank(
        query=question,
        documents=candidates,
        top_n=k_final,
        model="rerank-v3.5"
    )

    return [
        {
            "text": candidates[r.index],
            "rerank_score": r.relevance_score,
            "original_index": int(top_indices[r.index])
        }
        for r in rerank_response.results
    ]

Reranking b’LLM

Jekk tippreferi li ma żżidx fornitur ieħor mal-arkitettura tiegħek—minħabba raġunijiet kuntrattwali, lokalizzazzjoni tad-data, jew sempliċiment il-fatturar—LLM li diġà ssejjaħ jista’ jwettaq dan ir-rwol. Tibgħat il-mistoqsija u dokument, titlob punteġġ minn 0 sa 10, u tissortja. It-temperatura mwaqqfa fuq żero u max_tokens imnaqqsa għal ħamsa jiżguraw output deterministiku u rħis; il-try/except jittratta każijiet fejn il-mudell iwieġeb b’xi ħaġa ħlief numru.

from openai import OpenAI

client = OpenAI()

def llm_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[dict]:
    """Uses an LLM to score relevance."""
    scores = []

    for i, doc in enumerate(candidates):
        response = client.chat.completions.create(
            model="gpt-5.6-terra",
            messages=[{
                "role": "user",
                "content": (
                    f"On a scale of 0 to 10, how relevant is this document "
                    f"for answering the question?\n\n"
                    f"Question: {question}\n\n"
                    f"Document: {doc}\n\n"
                    f"Respond only with a number between 0 and 10."
                )
            }],
            temperature=0,
            max_tokens=5
        )
        try:
            score = float(response.choices[0].message.content.strip())
        except ValueError:
            score = 0.0
        scores.append({"index": i, "text": doc, "score": score})

    scores.sort(key=lambda x: x["score"], reverse=True)
    return scores[:k]

Din il-verżjoni tispiċċa sejħa waħda għal kull kandidat, jiġifieri għoxrin sejħa u daqshekk latenza kumulattiva għal mistoqsija waħda tal-utent. Fil-prattika, dan huwa projbittiv f’interfaċċa interattiva. Minflok, nitolbu lill-mudell jikklassifika d-dokumenti kollha f’daqqa, jippreżenta kull kandidat maqtugħ għal 200 karattru u nnumerat, u nistennew biss lista ta’ indiċi lura.

def llm_batch_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[int]:
    """Reranking in a single LLM call."""
    formatted_docs = "\n".join(
        f"[{i}] {doc[:200]}" for i, doc in enumerate(candidates)
    )

    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[{
            "role": "user",
            "content": (
                f"Rank these documents by relevance to the question. "
                f"Return the indices of the {k} most relevant "
                f"documents, separated by commas, from most to "
                f"least relevant.\n\n"
                f"Question: {question}\n\n"
                f"Documents:\n{formatted_docs}\n\n"
                f"Indices (e.g., 3,1,7,0,5):"
            )
        }],
        temperature=0,
        max_tokens=50
    )

    indices_str = response.choices[0].message.content.strip()
    return [int(i.strip()) for i in indices_str.split(",")][:k]

Integrazzjoni fil-Pipeline ta’ RAG

F’pipeline sħiħa, ir-reranking joqgħod bejn l-irkupru u l-ġenerazzjoni mingħajr ma jbiddel xejn ieħor. Il-punt ewlieni fil-klassi hawn taħt huwa l-limitu (threshold) ta’ 0.3 fuq relevance_score: dan jippermetti li tirritorna inqas minn ħames kuntesti meta l-ebda kandidat ma jkun verament rilevanti, minflok ma tingħata ħsejjes (noise) lill-ġeneratur. Spiss dan il-filtru, aktar mir-reranking innifsu, jelimina tweġibiet alluċinati.

class RAGPipelineWithReranking:
    def __init__(self):
        self.client = OpenAI()
        self.co = cohere.Client()

    def respond(self, question: str, chunks, embeddings_corpus):
        # 1. Broad retrieval
        candidates = self.search(question, embeddings_corpus, k=20)

        # 2. Reranking
        candidate_docs = [chunks[i]["text"] for i in candidates]
        reranked = self.co.rerank(
            query=question,
            documents=candidate_docs,
            top_n=5,
            model="rerank-v3.5"
        )

        # 3. Select the best
        contexts = [
            chunks[candidates[r.index]]
            for r in reranked.results
            if r.relevance_score > 0.3  # Relevance threshold
        ]

        # 4. Generate the answer
        return self.generate(question, contexts)

Impatt tar-Reranking

MetrikaMingħajr RerankingBir-RerankingGwadann
Recall@50.720.72=
Precision@50.580.78+34%
MRR0.650.82+26%

Dawn iċ-ċifri jgħiduk eżattament x’jagħmel reranker. Ir-Recall ma tiċċaqlaqx, u dan huwa loġiku: il-kandidati huma l-istess, u l-cross-encoder ma jistax isalva dokument li l-bi-encoder ma ħarġx fid-dieher. Madankollu, il-preċiżjoni u l-MRR itejbu b’mod sinifikanti, għax id-dokument it-tajjeb jimxi mis-sitt post għall-ewwel. Korollarju prattiku: jekk ir-Recall tiegħek huwa fqir, ir-reranking mhux se jsalvak; trid l-ewwel twessa’ l-irkupru jew terġa’ taħdem il-qtugħ (chunking).

Punti Ewlenin

  • Ir-reranking jerġa’ jikklassifika l-kandidati b’mudell aktar preċiż
  • Pipeline tipika: bi-encoder (l-aqwa 20–50) → cross-encoder (l-aqwa 5)
  • Cohere rerank-v3.5 hija soluzzjoni lest biex tuża
  • LLM jista’ jservi bħala reranker jekk tippreferi tevita dipendenza
  • Il-gwadann fil-preċiżjoni huwa sinifikanti (tipikament 20–35%)