Päring ja genereerimine
Sellel lehel
Vektorist vastuseni
Sa oskad juba dokumente indekseerida ja leida küsimusele lähimaid tulemusi. Järele on jäänud üks samm: muuta tükkide loend loetavaks vastuseks. See tähendab päritud konteksti sisestamist vihjesse, et suur keelemudel (LLM) formuleeriks vastuse sinu andmete põhjal, mitte oma treeningumälust. See võtab vaid paar rida koodi, kuid teeb kvaliteedis otsustava erinevuse. Hästi esitatud kontekst ja selge juhend on sama tähtsad kui päringu täpsus.
RAG-vihje koostamine
Vihje struktuur on lihtne, kuid igal valikul on tagajärjed. Numereeri tükid ja märgista nende allikas, et mudel saaks täpselt viidata. Eralda need nähtava eraldajaga ---, et mudel ei liidaks kahte vastuolulist dokumenti üheks väiteks. Kõige tähtsam on see, et juhend peab sõnaselgelt piirama vastuse ainult pakutud kontekstiga ja lubama mudelil öelda, et ta ei tea. Ilma selle loata täidab LLM puuduva info lüngad sellega, mis tundub usutav. See ongi hallutsinatsiooni mehhanism.
def build_rag_prompt(question, retrieved_chunks):
"""Ehita RAG-vihje päritud kontekstiga."""
# Vorminda kontekst
context_parts = []
for i, chunk in enumerate(retrieved_chunks):
source = chunk.get("source", "tundmatu allikas")
context_parts.append(f"[Dokument {i+1} - {source}]\n{chunk['text']}")
context = "\n\n---\n\n".join(context_parts)
prompt = f"""Sa oled ekspertassistent. Vasta küsimusele, kasutades
AINULT allpool toodud konteksti. Kui infot kontekstis ei ole,
ütle seda selgelt.
## Kontekst
{context}
## Küsimus
{question}
## Vastus"""
return prompt
Vastuse genereerimine
Genereerimise kutsumine on sirgjooneline: süsteemsõnum, mis kordab rolli, ja kasutajasõnum, mis kannab kokkupandud vihjet. Jälgi parameetrit temperature, mis on siin seatud väärtusele 0.1. Loomingulises kirjutamises soovid mitmekesisust; RAG-is soovid vastupidist. Sa tahad, et mudel püsiks võimalikult lähedal sellele, mida kontekst ütleb, ja et kaks käivitust sama küsimusega annaksid sama vastuse. Kõrge temperatuur sunniks mudelit ümber sõnastama, ekstrapoleerima ja allikast eemale kalduma.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def generate_answer(question, retrieved_chunks, model="mistral-large-latest"):
"""Genereeri RAG-vastus Mudraliga."""
prompt = build_rag_prompt(question, retrieved_chunks)
response = client.chat.complete(
model=model,
messages=[
{
"role": "system",
"content": "Sa oled täpne assistent, kes vastab pakutud konteksti põhjal."
},
{
"role": "user",
"content": prompt,
}
],
temperature=0.1, # Madal temperatuur faktiliste vastuste jaoks
)
return response.choices[0].message.content
# Näide
question = "Millised on RAG-i peamised sammud?"
results = search_index(question, index, chunks, k=3)
answer = generate_answer(question, results)
print(answer)
Voogu klassi kapseldamine
Hajusad funktsioonid sobivad uurimiseks, mitte tarnimiseks. Klass RAGPipeline koondab oleku – tükid, manuste maatriksi ja FAISS-indeksi, mis luuakse käivitamisel üks kord – ja kolm operatsiooni: retrieve kodeerib küsimuse ja pärib indeksit, generate koostab vihje ja kutsub mudelit ning ask aheldab need kaks kokku. Pane tähele, mida ask tagastab: mitte stringi, vaid sõnastikku, mis sisaldab vastust, allikate loendit ja kasutatud tükkide arvu. See jälgitavus eristab auditeeritavat assistenti mustast kastist. Päeval, kui kasutaja vaidlustab vastuse, tead sa, millistele lõikudele see tugines.
import numpy as np
import faiss
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
class RAGPipeline:
"""Täielik RAG-torustik Mistrali ja FAISS-iga."""
def __init__(self, chunks, embeddings):
self.chunks = chunks
self.embeddings = embeddings.astype(np.float32)
# Loo FAISS-indeks
dimension = embeddings.shape[1]
self.index = faiss.IndexFlatL2(dimension)
self.index.add(self.embeddings)
def retrieve(self, question, k=3):
"""Samm 1: päri asjakohased tükid."""
response = client.embeddings.create(
model="mistral-embed",
inputs=[question],
)
query_vector = np.array(
[response.data[0].embedding], dtype=np.float32
)
distances, indices = self.index.search(query_vector, k)
results = []
for dist, idx in zip(distances[0], indices[0]):
if idx >= 0:
results.append({
"text": self.chunks[idx]["text"],
"source": self.chunks[idx].get("source", ""),
"distance": float(dist),
})
return results
def generate(self, question, context_chunks):
"""Samm 2: genereeri vastus kontekstiga."""
prompt = build_rag_prompt(question, context_chunks)
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1,
)
return response.choices[0].message.content
def ask(self, question, k=3):
"""Täielik torustik: küsimus -> allikatega vastus."""
# Päring
context = self.retrieve(question, k=k)
# Genereerimine
answer = self.generate(question, context)
return {
"question": question,
"answer": answer,
"sources": [c["source"] for c in context],
"n_chunks_used": len(context),
}
# Kasutamine
rag = RAGPipeline(chunks, embeddings)
result = rag.ask("Kuidas indekseerimine FAISS-is toimib?")
print(f"Küsimus: {result['question']}")
print(f"Vastus: {result['answer']}")
print(f"Allikad: {result['sources']}")
Kolm vihjevarianti kasutusjuhu järgi
Saad baasvihjet spetsialiseerida sõltuvalt sellest, mida assistendilt ootad. Kui kasutajad peavad iga väidet kontrollima, küsi sõnaselgelt viiteid sulgudes. Mudel seob siis iga lause numbreeritud dokumendiga. Kui vastus toidab liidest või aruannet, sunnib struktureeritud vorming peale stabiilsed sektsioonid: lühike vastus, üksikasjad, allikad ja usaldustase, mis peegeldab seda, kui hästi kontekst küsimust katab. Kolmas variant mängib teistsugust rolli: see õpetab mudelit lahutama määramatust, eristades seda, mida ta saab väita, mida puudu on ja kuhu edasi vaadata. See toodab praktikas sageli kõige kasulikumaid assistente, sest „mul puudub X“ on parem kui enesekindel, kuid vale vastus.
# 1. Vihje viitamisjuhendiga
prompt_cite = """Vasta, viidates allikdokumentidele sulgudes.
Näide: "RAG parandab täpsust [Dokument 1]."
Kontekst: {context}
Küsimus: {question}"""
# 2. Vihje struktureeritud vorminguga
prompt_structured = """Vasta järgmises vormingus:
**Vastus**: [sinu lühike vastus]
**Üksikasjad**: [üksikasjalik selgitus]
**Allikad**: [kasutatud dokumentide loend]
**Usaldustase**: [kõrge/keskmine/madal põhinevalt konteksti katvusel]
Kontekst: {context}
Küsimus: {question}"""
# 3. Vihje puuduva info käsitlemisega
prompt_honest = """Kui kontekst ei sisalda piisavalt infot,
et täielikult vastata, säti selgelt:
- Mida saad kindlusega väita
- Mis on kontekstist puudu
- Ettepanekud puuduva info hankimiseks
Kontekst: {context}
Küsimus: {question}"""
Kutseparameetrite poolelt reguleerivad RAG-i käitumist kolm seadet. Madal temperatuur lukustab faktilise väljundi, max_tokens hoiab ära vastused, mis kalduvad esseedesse, ja konservatiivne top_p piirab valitud sõnavara tõenäolisimatele jätkudele.
# RAG-i jaoks kasuta madalat temperatuuri
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1, # Faktiline, madal loovus
max_tokens=1024, # Piira vastuse pikkust
top_p=0.95, # Konservatiivne tuumaproov
)
Peamised punktid
- RAG-vihje sisestab päritud konteksti enne küsimust
- Kasuta faktiliste vastuste jaoks madalat temperatuuri (0.1–0.3)
- Palu mudelil viidata allikatele jälgitavuse huvides
- Klass RAGPipeline kapseldab kogu voogu: päring, genereerimine, küsimine
- Käitle juhtumeid, kus kontekstist ei piisa