Uudelleenjärjestely: Osuvuuden parantaminen
Tällä sivulla
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
| Metric | Without Reranking | With Reranking | Gain |
|---|---|---|---|
| Recall@5 | 0.72 | 0.72 | = |
| Precision@5 | 0.58 | 0.78 | +34% |
| MRR | 0.65 | 0.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 %)