Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Uudelleenjärjestely: Osuvuuden parantaminen

Oppitunti 13 / 22 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Tavoitteet
  2. Bi-encoder-ongelma
  3. Uudelleenjärjestely Coherea käyttäen
  4. Uudelleenjärjestely LLM:llä
  5. Integrointi RAG-putkeen
  6. Uudelleenjärjestelyn vaikutus
  7. Keskeiset asiat

Tavoitteet

  • Ymmärrä, miksi uudelleenjärjestely parantaa tuloksia
  • Toteuta uudelleenjärjestelijä käyttämällä cross-encoder-mallia
  • Integroi uudelleenjärjestely RAG-putkeen

Bi-encoder-ongelma

Kaikki tähän mennessä rakentamasi haku perustuu bi-encoder-malliin: kysely ja dokumentit koodataan erikseen, toisistaan riippumatta, ja niitä verrataan pistetulon avulla. Tämä tekeehausta välitöntä jopa miljoonan tekstikatkelman joukossa, sillä kokoelman vektorit on laskettu kerran ja lopullisesti. Samasta syystä haku on epätarkka: malli ei näe kyselyä ja dokumenttia yhdessä, vaan sen on tiivistettävä kumpikin teksti vektoriksi tietämättä, mitä siltä myöhemmin kysytään.

Cross-encoder, jota kutsutaan myös uudelleenjärjestelijäksi (reranker), saa syötteekseen (kysely, dokumentti) -parin ja tuottaa huomattavasti tarkemman osuvuuspisteytyksen. Se lukee molemmat tekstit yhdessä ja pystyy havaitsemaan, käsitteleekö dokumentti aihetta vastakkaisessa merkityksessä. Tämä etu maksaa: mallin on käsiteltävä jokainen dokumentti erikseen, mikä estää sen käytön koko tekstikorpuksessa. Ratkaisu on käyttää sitä siellä, missä se on kustannustehokasta: pienelle, jo esivalitulle ehdokasjoukolle.

Näin syntyy kaksivaiheinen putki, jossa jokainen malli tekee sen, missä se on paras: nopea malli karsii joukkoa, ja tarkka malli tekee lopullisen valinnan.

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

Uudelleenjärjestely Coherea käyttäen

Cohere tarjoaa suorituskykyisen uudelleenjärjestelijän API:n kautta, jolloin mallin omaa isännöintiä ei tarvita. Seuraava funktio ketjuttaa kaksi vaihetta: se hakee ensin kaksikymmentä ehdokasta vektoriyhteyden perusteella ja pyytää sitten rerank-v3.5-mallia karsimaan listan viiteen. Huomaa tuloksessa säilyvä index_original-kenttä: uudelleenjärjestelijä palauttaa sijainnit suhteessa ehdokaslistaan, ja tarvitset tätä tietoa mapataksesi tulokset takaisin alkuperäisiin dokumentteihin korpuksessasi.

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
    ]

Uudelleenjärjestely LLM:llä

Jos et halua lisätä arkkitehtuuriisi uutta tarjoajaa – olipa syynä sopimukset, datan sijaintivaatimukset tai pelkkä laskutus – jo käyttämäsi LLM voi hoitaa tämän roolin. Lähetät kysymyksen ja dokumentin, pyydät pisteytystä väliltä 0–10 ja lajittelet tulokset. Lämpötilan asettaminen nollaan ja max_tokens-arvon rajoittaminen viiteen varmistavat deterministisen ja edullisen vasteen; try/except-lohko käsittelee tilanteet, joissa malli vastaa muulla kuin numerolla.

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]

Tämä versio maksaa yhden pyynnön ehdokasta kohden, eli kaksikymmentä kutsua ja vastaava viive yhtä käyttäjän kysymystä kohden. Käytännössä tämä on vuorovaikutteisessa käyttöliittymässä kohtuutonta. Sen sijaan pyydämme mallia järjestämään kaikki dokumentit kerralla: esitämme jokaisen ehdokkaan lyhennettynä 200 merkkiin ja numeroituna, odottaen vastaukseksi pelkkää indeksilistaa.

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]

Integrointi RAG-putkeen

Täydellisessä putkessa uudelleenjärjestely sijoittuu haun ja generoinnin väliin muuttamatta mitään muuta. Alla olevan luokan keskeinen kohta on relevance_score:n 0,3:n kynnysarvo: se mahdollistaa viittä pienemmän määrän kontekstien palauttamisen, jos mikään ehdokas ei ole todella osuva, sen sijaan että generaattorille syötettäisiin kohinaa. Usein juuri tämä suodatin – enemmän kuin itse uudelleenjärjestely – eliminoi hallusinaatiot vastauksista.

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)

Uudelleenjärjestelyn vaikutus

MetricWithout RerankingWith RerankingGain
Recall@50.720.72=
Precision@50.580.78+34%
MRR0.650.82+26%

Nämä luvut kertovat tarkasti, mitä uudelleenjärjestelijä tekee. Recall ei muutu, ja se on loogista: ehdokkaat ovat samat, eikä cross-encoder pysty pelastamaan dokumenttia, jota bi-encoder ei nostanut esiin. Sen sijaan precision ja MRR paranevat merkittävästi, koska oikea dokumentti nousee kuudennelta sijalta ensimmäiseksi. Käytännön johtopäätös: jos recallisi on heikko, uudelleenjärjestely ei pelasta tilannetta; sinun on ensin laajennettava hakua tai tarkistettava tekstikatkelointi.

Keskeiset asiat

  • Uudelleenjärjestely lajittelee ehdokkaat uudelleen tarkemmalla mallilla
  • Tyypillinen putki: bi-encoder (top 20–50) → cross-encoder (top 5)
  • Cohere rerank-v3.5 on valmis ratkaisu
  • LLM voi toimia uudelleenjärjestelijänä, jos haluat välttää riippuvuuksia
  • Tarkkuuden parannus on merkittävä (tyypillisesti 20–35 %)