Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Reranking: Poboljšanje relevantnosti

Lekcija 13 od 22 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Ciljevi
  2. Problem bi-encodera
  3. Reranking s Cohereom
  4. Reranking s LLM-om
  5. Integracija u RAG Pipeline
  6. Utjecaj rerankinga
  7. Ključne točke

Ciljevi

  • Razumjeti zašto reranking poboljšava rezultate
  • Implementirati reranker koristeći cross-encoder
  • Integrirati reranking u RAG pipeline

Problem bi-encodera

Sva pretraživanja koja si do sada izgradio/la oslanjaju se na bi-encoder: upit i dokumenti kodiraju se zasebno, sami za sebe, te se uspoređuju putem skalarnog umnoška. To je ono što pretraživanje čini trenutnim čak i kroz milijun isječaka, budući da su vektori korpusa izračunati jednom zauvijek. To je također razlog njegove nepreciznosti, jer model nikada ne vidi upit i dokument zajedno: mora sažeti svaki tekst u vektor ne znajući što će mu se kasnije tražiti.

Cross-encoder, koji se naziva i reranker, uzima par (upit, dokument) kao ulaz i proizvodi znatno precizniju ocjenu relevantnosti jer čita oba teksta zajedno i može detektirati da dokument raspravlja o temi, ali u suprotnom smislu. Ta dobit ima svoju cijenu: model mora obraditi svaki dokument pojedinačno, što onemogućuje njegovu primjenu na cijelom korpusu. Rješenje je koristiti ga tamo gdje je isplativo, na malom skupu kandidata koji su već ušli u uži izbor.

Odatle proizlazi dvostupanjski pipeline, gdje svaki model radi ono u čemu je najbolji: brzi sužava polje, a precizni donosi konačnu odluku.

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

Reranking s Cohereom

Cohere izlaže visokoperformantni reranker putem API-ja, čime se izbjegava hostiranje modela. Sljedeća funkcija povezuje dva koraka: prvo dohvaća dvadeset kandidata putem vektorske sličnosti, zatim traži od rerank-v3.5 da zadrži samo pet. Obrati pažnju na polje index_original sačuvano u rezultatu: reranker vraća pozicije relativne u odnosu na popis kandidata, a to ćeš trebati za mapiranje natrag na stvarni dokument u svom korpusu.

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]:
    """Semantičko pretraživanje + reranking."""
    # Korak 1: Brzo dohvaćanje (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]

    # Korak 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 s LLM-om

Ako ne želiš dodavati još jednog pružatelja usluga u svoju arhitekturu – zbog ugovornih razloga, lokalizacije podataka ili jednostavno naplate – LLM koji već koristiš može preuzeti tu ulogu. Pošalješ pitanje i dokument, zatražiš ocjenu od 0 do 10 i sortiraš rezultate. Postavljanje temperature na nulu i smanjenje max_tokens na pet osigurava deterministički i jeftin izlaz; blok try/except rješava slučajeve gdje model odgovori nečim drugim osim brojem.

from openai import OpenAI

client = OpenAI()

def llm_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[dict]:
    """Koristi LLM za ocjenjivanje relevantnosti."""
    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]

Ova verzija košta jedan poziv po kandidatu, što znači dvadeset poziva i jednaku kumulativnu latenciju za jedno korisničko pitanje. U praksi je to neprihvatljivo u interaktivnom sučelju. Umjesto toga, tražimo od modela da rangira sve dokumente odjednom, prikazujući svakog kandidata skraćenog na 200 znakova i numeriranog, očekujući zauzvrat samo popis indeksa.

def llm_batch_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[int]:
    """Reranking u jednom pozivu LLM-a."""
    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]

Integracija u RAG Pipeline

U potpunom pipelineu, reranking se uklapa između dohvaćanja i generiranja bez mijenjanja bilo čega drugoga. Ključna točka u donjoj klasi je prag od 0,3 na relevance_score: on omogućuje vraćanje manje od pet konteksta kada nijedan kandidat nije doista relevantan, umjesto da se generatoru šalje šum. Često ovaj filter, više nego samo reranking, eliminira halucinirane odgovore.

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

    def respond(self, question: str, chunks, embeddings_corpus):
        # 1. Široko dohvaćanje
        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. Odabir najboljih
        contexts = [
            chunks[candidates[r.index]]
            for r in reranked.results
            if r.relevance_score > 0.3  # Prag relevantnosti
        ]

        # 4. Generiranje odgovora
        return self.generate(question, contexts)

Utjecaj rerankinga

MetrikaBez rerankingaS rerankingomDobitak
Recall@50.720.72=
Precision@50.580.78+34%
MRR0.650.82+26%

Ove brojke precizno govore što reranker radi. Recall se ne mijenja, što je logično: kandidati su isti, a cross-encoder ne može spasiti dokument koji bi-encoder nije ni izvukao. Međutim, preciznost i MRR značajno se poboljšavaju jer se ispravan dokument seli s šestog na prvo mjesto. Praktična posljedica: ako ti je recall loš, reranking te neće spasiti; prvo moraš proširiti dohvaćanje ili revidirati chunking.

Ključne točke

  • Reranking ponovno rangira kandidate preciznijim modelom
  • Tipičan pipeline: bi-encoder (top 20–50) → cross-encoder (top 5)
  • Cohere rerank-v3.5 je gotovo rješenje
  • LLM može poslužiti kao reranker ako želiš izbjeći dodatnu ovisnost
  • Dobitak u preciznosti je značajan (obično 20–35%)