Retrieval un ģenerēšana
Šajā lapā
No vektora uz atbildi
Tu jau zini, kā indeksēt dokumentus un atlasīt tos, kas ir vistuvāk uzdotajam jautājumam. Atlicis tikai viens solis: pārvērst fragmentu sarakstu lasāmā atbildē. Tas nozīmē iegūtā konteksta ievadīšanu uzvednē (prompt), lai LLM formulētu atbildi, balstoties uz taviem datiem, nevis uz savu apmācības atmiņu. Tas prasa tikai dažas koda rindiņas, taču tas rada izšķirošu atšķirību kvalitātē. Labi noformēts konteksts un skaidra instrukcija ir tikpat svarīgi kā precīza atlase.
RAG uzvednes veidošana
Uzvednes struktūra ir vienkārša, taču katrai izvēlei ir sekas. Numerē fragmentus un norādi to avotu, lai modelis varētu precīzi citēt. Atdali tos ar redzamu atdalītāju ---, lai modelis neapvienotu divus pretrunīgus dokumentus vienā apgalvojumā. Vissvarīgākais: instrukcijai ir tieši jāierobežo atbilde tikai ar sniegto kontekstu un jāļauj modelim pateikt, ka tas nezina. Bez šīs atļaujas LLM, jautāts par trūkstošu informāciju, aizpildīs plaisu ar jebko, kas šķiet ticams. Tieši tāds ir halucināciju mehānisms.
def build_rag_prompt(question, retrieved_chunks):
"""Izveido RAG uzvedni ar iegūto kontekstu."""
# Formatē kontekstu
context_parts = []
for i, chunk in enumerate(retrieved_chunks):
source = chunk.get("source", "nezināms avots")
context_parts.append(f"[Dokuments {i+1} - {source}]\n{chunk['text']}")
context = "\n\n---\n\n".join(context_parts)
prompt = f"""Tu esi eksperts asistents. Atbildi uz jautājumu, izmantojot
TIKAI zemāk sniegto kontekstu. Ja informācijas kontekstā nav,
to skaidri norādi.
## Konteksts
{context}
## Jautājums
{question}
## Atbilde"""
return prompt
Atbildes ģenerēšana
Ģenerēšanas izsaukums ir vienkāršs: sistēmas ziņojums, kas atkārto lomu, un lietotāja ziņojums, kas satur sagatavoto uzvedni. Pievērs uzmanību temperatūras parametram, kas šeit iestatīts uz 0,1. Radošā rakstīšanā tev vajadzīga dažādība; RAG gadījumā – tieši pretēji. Tev ir jāpanāk, lai modelis pēc iespējas ciešāk pieturētos pie tā, kas teikts kontekstā, un lai divi izpildījumi ar vienu un to pašu jautājumu radītu vienu un to pašu atbildi. Augsta temperatūra mudinātu modeli pārrakstīt, ekstrapolēt un novirzīties no avota.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def generate_answer(question, retrieved_chunks, model="mistral-large-latest"):
"""Ģenerē RAG atbildi, izmantojot Mistral."""
prompt = build_rag_prompt(question, retrieved_chunks)
response = client.chat.complete(
model=model,
messages=[
{
"role": "system",
"content": "Tu esi precīzs asistents, kas atbild, balstoties uz sniegto kontekstu."
},
{
"role": "user",
"content": prompt,
}
],
temperature=0.1, # Zema temperatūra faktisku atbilžu iegūšanai
)
return response.choices[0].message.content
# Piemērs
question = "Kādi ir galvenie RAG soļi?"
results = search_index(question, index, chunks, k=3)
answer = generate_answer(question, results)
print(answer)
Plūsmas encapsulēšana klasē
Izkaisītas funkcijas der izpētei, bet ne nodošanai ekspluatācijā. Klase RAGPipeline apvieno stāvokli – fragmentus, iegulšanu (embeddings) matricu un FAISS indeksu, kas tiek izveidots vienreiz inicializācijas brīdī – un trīs operācijas: retrieve kodē jautājumu un veic vaicājumu indeksā, generate saliek uzvedni un izsauc modeli, bet ask savieno abus šos soļus. Ņem vērā, ko atgriež ask: nevis virkni, bet gan vārdnīcu, kas satur atbildi, avotu sarakstu un izmantoto fragmentu skaitu. Tieši šī izsekojamība atšķir auditējamu asistentu no melnās kastes. Dienā, kad lietotājs apstrīdēs atbildi, tu zināsi, uz kuriem fragmentiem tā balstījās.
import numpy as np
import faiss
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
class RAGPipeline:
"""Pilna RAG cauruļvada implementācija ar Mistral un FAISS."""
def __init__(self, chunks, embeddings):
self.chunks = chunks
self.embeddings = embeddings.astype(np.float32)
# Izveido FAISS indeksu
dimension = embeddings.shape[1]
self.index = faiss.IndexFlatL2(dimension)
self.index.add(self.embeddings)
def retrieve(self, question, k=3):
"""1. solis: atlasi atbilstošos fragmentus."""
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):
"""2. solis: ģenerē atbildi ar kontekstu."""
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):
"""Pilns cauruļvads: jautājums -> atbilde ar avotiem."""
# Atlase
context = self.retrieve(question, k=k)
# Ģenerēšana
answer = self.generate(question, context)
return {
"question": question,
"answer": answer,
"sources": [c["source"] for c in context],
"n_chunks_used": len(context),
}
# Lietošana
rag = RAGPipeline(chunks, embeddings)
result = rag.ask("Kā darbojas indeksēšana FAISS?")
print(f"Jautājums: {result['question']}")
print(f"Atbilde: {result['answer']}")
print(f"Avoti: {result['sources']}")
Trīs uzvedņu varianti atkarībā no lietojuma gadījuma
Tu vari specializēt bāzes uzvedni atkarībā no tā, ko sagaidi no asistenta. Ja lietotājiem ir jāpārbauda katrs apgalvojums, tieši pieprasi citātus iekavās. Tad modelis katram teikumam pievienos numurētu dokumentu. Ja atbilde tiek izmantota saskarnē vai ziņojumā, strukturēts formāts nodrošina stabilas sadaļas: kodolīga atbilde, detaļas, avoti un pārliecības līmenis, kas atspoguļo, cik labi konteksts sedz jautājumu. Trešais variants spēlē citu lomu: tas māca modelim sadalīt nenoteiktību, nošķirot to, ko tas var apgalvot, kas trūkst un kur meklēt tālāk. Praksē tas bieži rada visnoderīgākos asistentus, jo „man trūkst X” ir labāk nekā pārliecināta, bet nepareiza atbilde.
# 1. Uzvedne ar citēšanas instrukciju
prompt_cite = """Atbildi, citējot avota dokumentus iekavās.
Piemērs: "RAG uzlabo precizitāti [Dokuments 1]."
Konteksts: {context}
Jautājums: {question}"""
# 2. Uzvedne ar strukturētu formātu
prompt_structured = """Atbildi šādā formātā:
**Atbilde**: [tava kodolīgā atbilde]
**Detaļas**: [detalizēts skaidrojums]
**Avoti**: [izmantoto dokumentu saraksts]
**Pārliecība**: [augsta/vidēja/zema, balstoties uz konteksta pārklājumu]
Konteksts: {context}
Jautājums: {question}"""
# 3. Uzvedne ar trūkstošās informācijas apstrādi
prompt_honest = """Ja kontekstā nav pietiekami daudz informācijas,
lai pilnībā atbildētu, skaidri norādi:
- Ko vari apgalvot ar pārliecību
- Kas trūkst kontekstā
- Ieteikumus trūkstošās informācijas iegūšanai
Konteksts: {context}
Jautājums: {question}"""
Izsaukuma parametru ziņā trīs iestatījumi nosaka RAG uzvedību. Zema temperatūra fiksē faktisku izvadi, max_tokens novērš atbildes, kas pārvēršas esejas, bet konservatīvs top_p ierobežo izlases vārdu krājumu līdz visvarbūtīgākajiem turpinājumiem.
# RAG gadījumā izmanto zemu temperatūru
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1, # Faktisks, zema radošuma līmenis
max_tokens=1024, # Ierobežo atbildes garumu
top_p=0.95, # Konservatīva kodola izlase
)
Galvenās atziņas
- RAG uzvednē iegūtais konteksts tiek ievadīts pirms jautājuma
- Faktu balstītām atbildēm izmanto zemu temperatūru (0,1–0,3)
- Pieprasi modelim citēt avotus izsekojamības nodrošināšanai
- Klase
RAGPipelineencapsulē visu plūsmu: atlase, ģenerēšana, jautāšana - Atrisini gadījumus, kad kontekstā trūkst pietiekamas informācijas