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

Izguves papildināta uzvedņu veidošana

Nodarbība 9 no 16 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Izguves papildināta uzvedņu veidošana
  2. RAP sistēmas arhitektūra
  3. Pilns cauruļvads
  4. Sadalīšana fragmentos: dokumentu dalīšana
  5. Papildu izguves stratēģijas
  6. OpenAI iebūvētās failu meklēšanas izmantošana
  7. Izveido bāzes līniju
  8. Galvenās atziņas

Nodarbība atjaunināta 2026. gada 3. novembrī, pamatojoties uz OpenAI dokumentāciju: parametri temperature un top_p tiek pieņemti tikai tad, ja spriešanas piepūle ir none, savukārt GPT-5.6 modeļi pēc noklusējuma veic spriešanu (medium). Tādēļ izsaukumos, kuros iestatīti šie parametri, ir jānorāda reasoning={"effort": "none"} (Responses API) vai reasoning_effort="none" (Chat Completions). Avoti: Using GPT-6 · GPT-5.6 Terra.

Izguves papildināta uzvedņu veidošana

Izguves papildināta uzvedņu veidošana (Retrieval-Augmented Prompting jeb RAP) apvieno dokumentu meklēšanu ar uzvedņu veidošanu, lai nodrošinātu modelim atbilstošu un aktuālu kontekstu. Tas ir dabiskais pamatojuma (grounding) attīstības posms: manuālas konteksta ievades vietā tu automatizē atbilstošo fragmentu meklēšanu pirms katra LLM izsaukuma.

Atšķirība kļūst acīmredzama, strādājot lielos apjomos. Manuāla trīs noderīgu rindkopu ielīmēšana no tavas dokumentācijas der demonstrācijai, taču, tiklīdz dokumentu bāze sasniedz vairākus simtus lappušu un jautājumi pienāk nepārtraukti, neviens vairs nezina, kuri fragmenti jāielīmē. RAP deleģē šo izvēli automātiskajam komponentam, kas tiek izsaukts pirms katras ģenerēšanas un kura vienīgais uzdevums ir atrast, ko ievietot uzvednē.

RAP sistēmas arhitektūra

RAP cauruļvads sadalās trīs soļos, kas darbojas ar atšķirīgu ātrumu un izmaksām. Indeksēšana pārveido tavus dokumentus vektoru iegulumos (embeddings); tas notiek vienreiz, bezsaistē, pārvēršot katru dokumentu skaitliskā vektorā, kas kodē tā nozīmi un tiek glabāts kopā ar oriģināltekstu. Izguve (retrieval), turpretī, notiek katrā jautājumā: tu pārveido jautājumu vektorā, izmantojot to pašu ieguluma modeli, un pēc tam meklē tuvākos dokumentu vektorus. Visbeidzot, papildināšana ir vienkārši standarta uzvedņu veidošana — tu izveido sistēmas uzvedni, kas satur atlasītos fragmentus, un norādi modelim neiet ārpus šīm robežām.

Atceries šo dalījumu: viss, kas ir dārgi, notiek indeksēšanas laikā, kur vari atļauties būt prasīgs, savukārt viss, kas atkārtojas katram jautājumam, ir jābūt ātram. Zemāk esošais kods īsteno pirmos divus soļus, izmantojot kosinusa līdzību kā tuvuma mēru.

from openai import OpenAI
import numpy as np

client = OpenAI()

# 1. solis: Ģenerēt dokumentu iegulumus
def embed_texts(texts: list[str]) -> list[list[float]]:
    """Ģenerē iegulumus tekstu sarakstam."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=texts
    )
    return [item.embedding for item in response.data]

# 2. solis: Meklēšana pēc kosinusa līdzības
def cosine_similarity(a: list[float], b: list[float]) -> float:
    """Aprēķina kosinusa līdzību starp diviem vektoriem."""
    a, b = np.array(a), np.array(b)
    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))

def retrieve(query: str, documents: list[str],
             doc_embeddings: list[list[float]],
             top_k: int = 3) -> list[str]:
    """Atgriež top_k atbilstošākos dokumentus."""
    query_emb = embed_texts([query])[0]

    scores = [
        (i, cosine_similarity(query_emb, doc_emb))
        for i, doc_emb in enumerate(doc_embeddings)
    ]
    scores.sort(key=lambda x: x[1], reverse=True)

    return [documents[i] for i, _ in scores[:top_k]]

Pilns cauruļvads

Apvienojot šos būvblokus, iegūst klasi, kas ietilpst aptuveni trīsdesmit rindās. Lielākā daļa lēmumu tiek pieņemti ģenerētajā sistēmas uzvednē, un ir vērts to izlasīt rindu pa rindai. Modelis vispirms saņem rīkojumu atbildēt TIKAI, pamatojoties uz sniegtajiem fragmentiem, kas ierobežo halucinācijas, ja dokumentācijā trūkst atbildes. Tad tas saņem norādi katram apgalvojumam citēt fragmenta numuru, un tieši tas padara pārbaudi iespējamu: recenzents var acumirklī izsekot avotam. temperature vērtība 0.1 pabeidz iestatījumu — atbildē, kas balstīta dokumentos, radošums ir kļūda.

class RAGPipeline:
    "Minimālistisks RAP cauruļvads."

    def __init__(self, documents: list[str]):
        self.documents = documents
        self.embeddings = embed_texts(documents)

    def query(self, question: str, top_k: int = 3) -> str:
        """Atbild uz jautājumu, pamatojoties uz dokumentiem."""
        # Izguve
        relevant_docs = retrieve(
            question, self.documents,
            self.embeddings, top_k
        )

        # Uzvednes papildināšana
        context = "\n\n---\n\n".join(
            f"[Passage {i+1}]\n{doc}"
            for i, doc in enumerate(relevant_docs)
        )

        system = f"""You are a technical assistant.
Answer ONLY based on the provided passages.
If the passages do not contain the answer, say so.
Cite the passage number for every claim.

RELEVANT PASSAGES:
{context}"""

        # Ģenerēšana
        response = client.responses.create(
            model="gpt-5.6-terra",
            reasoning={"effort": "none"},  # temperature requires effort none
            instructions=system,
            input=question,
            temperature=0.1
        )
        return response.output_text

Sadalīšana fragmentos: dokumentu dalīšana

Dokumentu sadalīšana fragmentos (chunking) ir kritiski svarīga izguves kvalitātei. Ja fragmenti ir pārāk lieli, tie noslāpē atbilstošo informāciju; ja pārāk mazi, tie zaudē kontekstu. API rokasgrāmata, sadalīta desmit lappušu blokos, vienmēr atgriezīs to pašu vispārīgo bloku neatkarīgi no uzdotā jautājuma. Sadalīta izolētos teikumos, tā atgriezīs teikumu, kas sākas ar „šī metode”, un modelis nezinās, kura metode tiek domāta. Pārklāšanās (overlap) tieši mazina šo risku: katrs fragments atkārto iepriekšējā beigas, tāpēc informācija, kas sniedzas pāri robežai, palasa vismaz no vienas puses.

Ja taviem dokumentiem ir virsrakstu struktūra, sadalīšana pa sadaļām gandrīz vienmēr ir pārāka par fiksēta izmēra sadalīšanu: sadaļa „Autentifikācija” paliek neskarta kopā ar savu ievadu un piemēriem.

def chunk_document(text: str, chunk_size: int = 500,
                   overlap: int = 50) -> list[str]:
    """Sadalīt tekstu fragmentos ar pārklāšanos."""
    words = text.split()
    chunks = []

    for i in range(0, len(words), chunk_size - overlap):
        chunk = " ".join(words[i:i + chunk_size])
        if chunk.strip():
            chunks.append(chunk)

    return chunks

def chunk_by_sections(text: str) -> list[str]:
    """Sadalīt pa sadaļām (Markdown virsraksti)."""
    sections = []
    current = []

    for line in text.split("\n"):
        if line.startswith("## ") and current:
            sections.append("\n".join(current))
            current = [line]
        else:
            current.append(line)

    if current:
        sections.append("\n".join(current))

    return sections

Papildu izguves stratēģijas

Pārkārtošana (Reranking)

Pēc sākotnējās izguves izmanto LLM, lai pārkārtotu rezultātus. Loģika ir piltuves veidā: vektoru meklēšana ir ātra, bet aptuvena, atgriežot duci ticamu kandidātu; modelis, lai gan lēnāks, bet niansētāks, pārlasa šos kandidātus, zinot jautājumu, un tos rangē. Tad ģenerēšanai atstāj tikai saraksta augšgalu. Ieguvums ir visredzamākais jautājumos, kur vairāki fragmenti runā par vienu tēmu, bet tikai viens faktiski sniedz atbildi — trīs sadaļas min vārdu „kvota”, bet tikai viena paskaidro, kā to palielināt.

def rerank(question: str, passages: list[str]) -> list[str]:
    """Pārkārto fragmentus pēc atbilstības, izmantojot LLM."""
    prompt = f"""Question: {question}

Here are candidate passages. Rank them from most relevant
to least relevant for answering the question.
Return only the numbers in order (e.g., 3, 1, 2).

{chr(10).join(f"[{i+1}] {p[:200]}" for i, p in enumerate(passages))}"""

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=prompt,
        temperature=0.0
    )
    # Parsēt atgriezto secību un pārkārtot
    return response.output_text

Hipotētiskā dokumenta iegulums (HyDE)

Ģenerē ideālu hipotētisku dokumentu, pēc tam meklē līdzīgus dokumentus. Problēma, ko šī metode risina, ir vocabulāra nesakritība: jautājums, uzdots ikdienas valodā, vektoru telpā neizskatās līdzīgs tehniskās dokumentācijas rindkopai. Vispirms lūdzot modelim uzrakstīt atbildi, ko tas iedomājas, tu iegūsti tekstu, rakstītu tavu dokumentu stilistikā, un tieši šo tekstu izmanto kā vaicājumu. Nav svarīgi, ja hipotētiskajā rindkopā ir neprecizitātes: tā nekad netiek izmantota kā atbilde, tikai kā zonde.

def hyde_retrieve(question: str, documents: list[str],
                  doc_embeddings: list[list[float]]) -> list[str]:
    """Izguve, izmantojot HyDE."""
    # Ģenerēt hipotētisku fragmentu
    hypo_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=f"Write a short technical paragraph that would perfectly "
              f"answer this question: {question}",
        temperature=0.5
    )
    hypothetical_doc = hypo_response.output_text

    # Meklēt dokumentus, kas līdzīgi hipotētiskajam fragmentam
    return retrieve(hypothetical_doc, documents,
                    doc_embeddings, top_k=3)

OpenAI iebūvētās failu meklēšanas izmantošana

Ātrai izvēršanai API piedāvā integrētu izguvi. Tu augšupielādē failu, izveido vektoru krātuvi, pievieno tai failu un izsaukumā deklarē rīku file_search: sadalīšana fragmentos, iegulums un meklēšana tiek apstrādāta servera pusē. Šī ir pareizā izvēle, ja tavi dokumenti ir standarta un tev nav svarīgi, kur dati glabājas. Pašizveidotais cauruļvads saglabā priekšrocības tiklīdz tev ir nepieciešams pilnībā kontrolēt sadalīšanu fragmentos, mitināt indeksu pašam vai pieslēgt specifisku pārkārtošanu.

# Augšupielādēt failu
file = client.files.create(
    file=open("documentation.pdf", "rb"),
    purpose="assistants"
)

# Izveidot vektoru krātuvi
vector_store = client.vector_stores.create(
    name="Technical Documentation"
)

client.vector_stores.files.create(
    vector_store_id=vector_store.id,
    file_id=file.id
)

# Vaicājums ar failu meklēšanu
response = client.responses.create(
    model="gpt-5.6-terra",
    instructions="Answer based on the provided documentation.",
    input="How do I configure authentication?",
    tools=[{
        "type": "file_search",
        "vector_store_ids": [vector_store.id]
    }]
)

Izveido bāzes līniju

Paņem piecas līdz desmit tehniskās dokumentācijas lappuses un īsteno pilnu cauruļvadu, sākot no sadalīšanas fragmentos līdz ģenerēšanai. Uzraksti desmit jautājumus, kuru atbildes ir dokumentos, palaid cauruļvadu katram no tiem, pēc tam atkārto procesu ar ieslēgtu pārkārtošanu: tieši vērojot, pie kuriem jautājumiem rangs mainās, tu saproti, ko viena vektoru meklēšana palaiž garām. Nobeigumā izmēri pareizi pamatoto atbilžu procentuālo daļu — tās, kurā katrs apgalvojums faktiski atsaucas uz sniegto fragmentu. Šis skaitlis ir tavs sākumpunkts; visi turpmākie optimizējumi tiks vērtēti pret to, nevis pret iespaidu, ko atstāj divas vai trīs nejauši izlasītas atbildes.

Galvenās atziņas

  • RAP automatizē atbilstoša konteksta ievadi uzvednē
  • Sadalīšana fragmentos ir kritiska: eksperimentē ar dažādiem izmēriem
  • Pārkārtošana, izmantojot LLM, būtiski uzlabo atbilstību
  • HyDE ir noderīga, ja jautājums krasi atšķiras no dokumentu vocabulāra
  • OpenAI File Search vienkāršo izvēršanu standarta gadījumos