Премини към основното съдържание
Български— Изберете език
Меню

Преподреждане: Подобряване на релевантността

Урок 13 от 22 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Цели
  2. Проблемът с би-енкодера
  3. Преподреждане с Cohere
  4. Преподреждане с LLM
  5. Интеграция в RAG конвейера
  6. Въздействие на преподреждането
  7. Ключови изводи

Цели

  • Да разберете защо преподреждането подобрява резултатите
  • Да внедрите преподредител (reranker), използващ кръстовиден енкодер (cross-encoder)
  • Да интегрирате преподреждането в RAG конвейер

Проблемът с би-енкодера

Цялото търсене, което сте изградили досега, разчита на би-енкодер: заявката и документите се кодират отделно, сами по себе си, и се сравняват чрез скаларно произведение. Това прави търсенето мигновено дори сред милион чънка, тъй като векторите на корпуса са изчислени веднъж завинаги. Същото това обаче го прави и неточно, защото моделът никога не вижда заявката и документа заедно: той трябва да обобщи всеки текст във вектор, без да знае какво ще бъде попитано по-късно.

Кръстовидният енкодер (cross-encoder), наричан още преподредител, приема двойката (заявка, документ) като вход и генерира много по-фин резултат за релевантност, тъй като прочита двата текста съвместно и може да открие, че един документ обсъжда темата, но в противоположен смисъл. Това предимство има своята цена: моделът трябва да обработва всеки документ поотделно, което забранява използването му върху целия корпус. Решението е да се използва там, където е икономически изгодно – върху малък набор от кандидати, вече предварително подбрани.

Оттук идва и двуетапният конвейер, където всеки модел прави онова, за което е най-добър: бързият стеснява кръга, а точният прави окончателния подбор.

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

Преподреждане с Cohere

Cohere предоставя високопроизводителен преподредител чрез API, което избягва необходимостта от хостване на модел. Следната функция свързва двете стъпки: първо извлича двадесет кандидата чрез векторно сходство, след което иска от rerank-v3.5 да задържи само пет. Обърнете внимание на полето index_original, запазено в резултата: преподредителят връща позиции спрямо списъка с кандидати и ще Ви е необходимо това, за да ги картографирате обратно към действителния документ във Вашия корпус.

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
    ]

Преподреждане с LLM

Ако предпочитате да не добавяте друг доставчик към Вашата архитектура – поради договорни причини, локализация на данни или просто фактуриране – LLM, който вече използвате, може да поеме тази роля. Изпращате въпроса и документа, искате оценка от 0 до 10 и сортирате. Температурата, зададена на нула, и max_tokens, намалени до пет, осигуряват детерминиран и евтин изход; блокът try/except обработва случаите, в които моделът отговаря с нещо различно от число.

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]

Тази версия струва едно извикване на кандидат, което означава двадесет извиквания и съответно натрупано забавяне за един потребителски въпрос. На практика това е неприемливо в интерактивен интерфейс. Вместо това искаме от модела да подреди всички документи наведнъж, представяйки всеки кандидат съкратен до 200 знака и номериран, очаквайки в замяна само списък с индекси.

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]

Интеграция в RAG конвейера

В един завършен конвейер преподреждането се вмества между извличането и генерирането, без да променя нищо друго. Ключовият момент в класа по-долу е прагът от 0.3 за relevance_score: той позволява връщането на по-малко от пет контекста, когато никой кандидат не е наистина релевантен, вместо да се подава шум на генератора. Често този филтър, повече от самото преподреждане, елиминира халюцинаторните отговори.

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)

Въздействие на преподреждането

МетрикаБез преподрежданеС преподрежданеПечалба
Recall@50.720.72=
Precision@50.580.78+34%
MRR0.650.82+26%

Тези цифри показват точно какво прави един преподредител. Recall не се променя и това е логично: кандидатите са същите, а кръстовидният енкодер не може да спаси документ, който би-енкодерът не е извел на преден план. Въпреки това, precision и MRR се подобряват значително, защото правилният документ се премества от шесто на първо място. Практическо следствие: ако Вашият recall е слаб, преподреждането няма да Ви спаси; първо трябва да разширите извличането или да преразгледате стратегията за чънкване.

Ключови изводи

  • Преподреждането пренарежда кандидатите с по-прецизен модел
  • Типичен конвейер: би-енкодер (топ 20–50) → кръстовиден енкодер (топ 5)
  • Cohere rerank-v3.5 е готово решение «ключ в ръка»
  • LLM може да служи като преподредител, ако предпочитате да избегнете допълнителна зависимост
  • Печалбата в точността е значителна (обикновено 20–35%)