Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Pārkārtotā rangā: atbilstības uzlabošana

Nodarbība 13 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Mērķi
  2. Divkāršā kodētāja problēma
  3. Pārkārtotā ranga veikšana ar Cohere
  4. Pārkārtotā ranga veikšana ar LLM
  5. Integrācija RAG cauruļvadā
  6. Pārkārtotā ranga ietekme
  7. Galvenās atziņas

Mērķi

  • Saprast, kāpēc pārkārtotā ranga (reranking) uzlabo rezultātus
  • Ieviest pārkārtotāju, izmantojot krustenisko kodētāju (cross-encoder)
  • Integrēt pārkārtoto rangu RAG cauruļvadā

Divkāršā kodētāja problēma

Visa līdz šim izveidotā meklēšana balstās uz divkāršo kodētāju (bi-encoder): vaicājums un dokumenti tiek kodēti atsevišķi, neatkarīgi viens no otra, un salīdzināti, izmantojot skalāro reizinājumu. Tieši tas padara meklēšanu acumirklīgu pat miljona fragmentu apjomā, jo korpusa vektori ir aprēķināti vienreiz un uz visiem laikiem. Tas arī ir iemesls, kāpēc tā ir neprecīza: modelis nekad neredz vaicājumu un dokumentu kopā; tam ir jāapkopo katrs teksts vektorā, nezinot, kas tam vēlāk tiks prasīts.

Krusteniskais kodētājs (cross-encoder), ko dēvē arī par pārkārtotāju, kā ievadi saņem pāri (vaicājums, dokuments) un ģenerē daudz precīzāku atbilstības vērtējumu, jo tas nolasa abus tekstus kopīgi un spēj noteikt, ka dokuments apspriež tēmu, bet pretējā nozīmē. Šis ieguvums ir saistīts ar izmaksām: modelim katrs dokuments jāapstrādā individuāli, kas aizliedz to izmantot visam korpusam. Risinājums ir izmantot to tur, kur tas ir izdevīgi, – nelielam jau atlasītu kandidātu kopumam.

Tādējādi veidojas divu posmu cauruļvads, kur katrs modelis dara to, ko prot vislabāk: ātrais sašaurina lauku, bet precīzais veic galīgo atlasi.

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

Pārkārtotā ranga veikšana ar Cohere

Cohere piedāvā augstas veiktspējas pārkārtotāju, izmantojot API, kas ļauj izvairīties no modeļa mitināšanas pašam. Tālāk redzamā funkcija savieno abus soļus: tā vispirms iegūst divdesmit kandidātus, izmantojot vektoru līdzību, un pēcāk pieprasa rerank-v3.5 atstāt tikai piecus. Ņem vērā lauku index_original, kas tiek saglabāts rezultātā: pārkārtotājs atgriež pozīcijas attiecībā pret kandidātu sarakstu, un tas tev būs nepieciešams, lai atgrieztos pie faktiskā dokumenta savā korpusā.

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]:
    """Semantiskā meklēšana + pārkārtotais rangs."""
    # 1. solis: Ātra iegūšana (divkāršais kodētājs)
    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]

    # 2. solis: Pārkārtotais rangs (krusteniskais kodētājs)
    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
    ]

Pārkārtotā ranga veikšana ar LLM

Ja nevēlies savai arhitektūrai pievienot vēl vienu nodrošinātāju – līgumisku iemeslu, datu lokalizācijas vai vienkārši rēķinu dēļ –, šo lomu var uzņemties LLM, ko jau izmanto. Tu iesniedz jautājumu un dokumentu, pieprasi vērtējumu no 0 līdz 10 un sakārto tos. Temperatūras iestatīšana uz nulli un max_tokens samazināšana līdz pieciem nodrošina deterministisku un lētu izvadi; bloks try/except apstrādā gadījumus, kad modelis atbild ar kaut ko citu, nevis skaitli.

from openai import OpenAI

client = OpenAI()

def llm_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[dict]:
    """Izmanto LLM, lai vērtētu atbilstību."""
    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]

Šī versija izmaksā vienu izsaukumu uz katru kandidātu, kas nozīmē divdesmit izsaukumus un tikpat lielu kopējo latentumu vienam lietotāja jautājumam. Praksē tas interaktīvā saskarnē ir nepieņemami. Tā vietā mēs lūdzam modeli sakārtot visus dokumentus vienlaikus, parādot katru kandidātu, saīsinātu līdz 200 rakstzīmēm un numurētu, sagaidot atbildē tikai indeksu sarakstu.

def llm_batch_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[int]:
    """Pārkārtotais rangs vienā LLM izsaukumā."""
    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]

Integrācija RAG cauruļvadā

Pilnīgā cauruļvadā pārkārtotais rangs iekļaujas starp iegūšanu un ģenerēšanu, nemainot neko citu. Galvenais moments tālāk redzamajā klasē ir slieksnis 0,3 attiecībā uz relevance_score: tas ļauj atgriezt mazāk nekā piecus kontekstus, ja neviens kandidāts nav patiesi atbilstošs, tā vietā, lai ģeneratoram padotu trokšņus. Bieži vien šis filtrs, vairāk nekā pats pārkārtotais rangs, novērš halucinētas atbildes.

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

    def respond(self, question: str, chunks, embeddings_corpus):
        # 1. Plaša iegūšana
        candidates = self.search(question, embeddings_corpus, k=20)

        # 2. Pārkārtotais rangs
        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. Labāko atlase
        contexts = [
            chunks[candidates[r.index]]
            for r in reranked.results
            if r.relevance_score > 0.3  # Atbilstības slieksnis
        ]

        # 4. Atbildes ģenerēšana
        return self.generate(question, contexts)

Pārkārtotā ranga ietekme

MetrikaBez pārkārtotā rangaAr pārkārtoto ranguPieaugums
Recall@50.720.72=
Precision@50.580.78+34%
MRR0.650.82+26%

Šie skaitļi precīzi parāda, ko dara pārkārtotājs. Atmiņa (Recall) nemainās, un tas ir loģiski: kandidāti ir tie paši, un krusteniskais kodētājs nevar glābt dokumentu, ko divkāršais kodētājs nav izvirzījis priekšplānā. Tomēr precizitāte un MRR ievērojami uzlabojas, jo pareizais dokuments pārvietojas no sestās vietas uz pirmo. Praktiskas sekas: ja tava atmiņa ir vāja, pārkārtotais rangs tevi neglābs; vispirms ir jāpaplašina iegūšana vai jāpārskata fragmentēšana.

Galvenās atziņas

  • Pārkārtotais rangs pārkārto kandidātus, izmantojot precīzāku modeli
  • Tipisks cauruļvads: divkāršais kodētājs (top 20–50) → krusteniskais kodētājs (top 5)
  • Cohere rerank-v3.5 ir gatavs risinājums
  • LLM var kalpot kā pārkārtotājs, ja vēlies izvairīties no atkarībām
  • Precizitātes pieaugums ir ievērojams (parasti 20–35%)