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

Paškonsekvence: vairāki spriešanas ceļi

Nodarbība 6 no 16 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Paškonsekvence: vairāki spriešanas ceļi
  2. Problēma, ko tā risina
  3. Pamata implementācija
  4. Ko tev stāsta balsojums
  5. Paralēlā versija ar asyncio
  6. Kad lietot paškonsekvenci
  7. Izmaksu un uzticamības attiecības noregulēšana
  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 ar spriešanas piepūli none, savukārt GPT-5.6 modeļi pēc noklusējuma veic spriešanu (medium). Tāpēc 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.

Paškonsekvence: vairāki spriešanas ceļi

Paškonsekvence nozīmē vairāku neatkarīgu atbilžu ģenerēšanu vienam un tam pašam uzdevumam, pēc tam izvēloties biežāko vai loģiskāko. Princips ir balsošana: viens izsaukums pakļauj tevi nejaušībai un sliktam “lozējumam”, bet pieci izsaukumi dod sadalījumu, ko vari analizēt. Šī metode būtiski uzlabo atbilžu uzticamību, it īpaši loģiskās spriešanas un matemātiskajos uzdevumos.

Problēma, ko tā risina

LLM var sniegt atšķirīgu atbildi katrā izsaukumā, pat ja uzdevums ir stingri identisks. Dažas no šīm atbildēm ir pareizas, citas – nē, un izejā nekas neliecina, kuru tu lasi: nepareiza atbilde tiek pausta ar tādu pašu pārliecību kā pareiza. Paškonsekvence pārvērš šo mainīgumu tavā labā. Ja modelis nonāk pie viena un tā paša secinājuma, izmantojot vairākus dažādus spriešanas ceļus, šis secinājums, visticamāk, ir pareizs; turpretī kļūda reti atkārtojas identiski no viena “lozējuma” uz nākamo, jo tā ir atkarīga tieši no izvēlētā ceļa.

Pamata implementācija

Mehānismam ir trīs soļi: ģenerē, izgūst gala atbildi, balso. Marķieris >>> ANSWER:, kas piespiests instrukcijās, nav tikai kosmētika – tieši tas ļauj izeju parsēt, neinterpretējot iepriekšējo spriešanu. Bez šī enkura tev būtu jāraksta trauslu heuristiku, lai minētu, kur beidzas pārdomas un sākas secinājums.

from openai import OpenAI
from collections import Counter

client = OpenAI()

def self_consistency(prompt: str, system: str = "",
                     n: int = 5, model: str = "gpt-5.6-terra") -> dict:
    """Ģenerē n atbildes un atgriež biežāko."""
    responses = []

    for _ in range(n):
        response = client.responses.create(
            model=model,
            reasoning={"effort": "none"},  # temperature prasa effort none
            instructions=system + "\nSpried soli pa solim, tad sniedz "
                         "savu gala atbildi pēc '>>> ANSWER:'",
            input=prompt,
            temperature=0.7  # Temperature > 0 dažādībai
        )
        responses.append(response.output_text)

    # Izgūst gala atbildes
    answers = []
    for r in responses:
        if ">>> ANSWER:" in r:
            answer = r.split(">>> ANSWER:")[-1].strip()
            answers.append(answer)

    # Balsu vairākums
    if answers:
        counter = Counter(answers)
        best_answer, count = counter.most_common(1)[0]
        return {
            "answer": best_answer,
            "confidence": count / len(answers),
            "all_answers": dict(counter),
            "total_responses": len(answers)
        }
    return {"answer": None, "confidence": 0}

Ko tev stāsta balsojums

Pielietojot sentimenta klasifikācijai, funkcija atgriež ne tikai etiķeti, bet arī sadalījumu, un šis sadalījums bieži vien ir vērtīgāks par pašu etiķeti. Zemāk redzamajam apskatam, kas ir patiesi neskaidrs – produkts ir labs, bet piegāde bija katastrofāla – četri izsaukumi nobalsoja par “negatīvu” un trīs par “neitrālu”. 57 % pārliecība norāda, ka šis gadījums varētu pelnīt īpašu apstrādi: rindā cilvēka pārbaudei, lietotāja precizējuma pieprasīšanai vai vienkārši izslēgšanai no apkopotās statistikas. Viens izsaukums būtu parādījis “negatīvu” bez niansēm, un tu būtu apstrādājis šo pieteikumu tieši tāpat kā vienbalsīgi dusmīgu atsauksmi.

system = """Tu esi sentimenta klasifikators.
Analizē tekstu un spried soli pa solim.
Sniedz savu gala atbildi pēc '>>> ANSWER:', izvēloties no:
positive, negative, neutral"""

text = "The product is fine but the delivery took 3 weeks."

result = self_consistency(text, system, n=7)
print(f"Sentiments: {result['answer']}")
print(f"Pārliecība: {result['confidence']:.0%}")
print(f"Sadalījums: {result['all_answers']}")
# Piemēra izvade:
# Sentiments: negative
# Pārliecība: 57%
# Sadalījums: {'negative': 4, 'neutral': 3}

Paralēlā versija ar asyncio

Šīs tehnikas izmaksas nav tikai finansiālas: pieci secīgi izsaukumi nozīmē arī piecas reizes lielāku latentumu, kas izslēdz šo pieeju jebkurā saskarnē, kur kāds gaida pie ekrāna. Taču izsaukumi ir pilnīgi neatkarīgi; nav nekāda pamata gaidīt tos vienu pēc otra. asyncio.gather samazina kopējo laiku līdz lēnākā izsaukuma ilgumam, padarot paškonsekvenci saderīgu ar tiešsaistes lietojumiem, kur pieskaitāmās izmaksas kļūst tikai monetāras.

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

async def self_consistency_async(prompt: str, system: str = "",
                                  n: int = 5) -> dict:
    """Paškonsekvences asinhronā versija."""

    async def single_call():
        response = await async_client.responses.create(
            model="gpt-5.6-terra",
            reasoning={"effort": "none"},  # temperature prasa effort none
            instructions=system + "\nSpried, tad sniedz savu atbildi "
                         "pēc '>>> ANSWER:'",
            input=prompt,
            temperature=0.7
        )
        return response.output_text

    # Palaid visus pieprasījumus paralēli
    tasks = [single_call() for _ in range(n)]
    results = await asyncio.gather(*tasks)

    # Izgūst un balso
    answers = []
    for r in results:
        if ">>> ANSWER:" in r:
            answers.append(r.split(">>> ANSWER:")[-1].strip())

    counter = Counter(answers)
    best, count = counter.most_common(1)[0] if answers else (None, 0)

    return {
        "answer": best,
        "confidence": count / len(answers) if answers else 0,
        "distribution": dict(counter)
    }

Kad lietot paškonsekvenci

Lēmuma kritērijs ir vienkāršs: balsošanai ir jēga tikai tad, ja atbilde ir diskrēta un salīdzināma. Divus labi uzrakstītus kopsavilkumus nevar saskaitīt, jo tie nekad nebūs rakstzīmju ziņā identiski; divas kategoriju etiķetes – var.

Lietojums Noderīgi? Kāpēc
Klasifikācija Jā Diskrēta atbilde, vienkārša balsošana
Matemātiskā spriešana Jā Vairāki ceļi uz pareizo atbildi
Entitāšu ekstrakcija Jā Konsenss par noteiktajām entitātēm
Radošā rakstīšana Nē Nav vienas "pareizas" atbildes
Teksta kopsavilkums Daļēji Noderīgi galvenajiem faktiem, ne stilam

Izmaksu un uzticamības attiecības noregulēšana

Trīs izsaukumi ir minimālais skaits, lai balsu vairākumam būtu jēga; pieci piedāvā labāko kompromisu vairumam lietojumu; septiņi līdz vienpadsmit ir attaisnojami kritiskiem lēmumiem, kur kļūda izmaksā daudz vairāk nekā daži papildu izsaukumi. Tomēr īstais ieguvums slēpjas tajā, kā tu izmanto pārliecības rādītāju, nevis izlases lielumu. Zem 60 % uzskati, ka konsensa nav, un eskalē situāciju – vai nu cilvēka operatoram, vai jaudīgākam modelim ar vairāk izlases paraugiem, kā parādīts zemāk.

result = self_consistency(question, system, n=5)

if result["confidence"] < 0.6:
    # Nav skaidra konsensa, eskalē
    result = self_consistency(question, system, n=9, model="gpt-5.6-sol")

Atlikušais jautājums ir, vai spēle ir sveces vērta tieši tavā gadījumā, un tas ir jāmēra, nevis jāpieņem. Implementē asinhrono versiju, palaid to uz duci sentimenta klasifikācijas jautājumiem, kuros zini paredzamo atbildi, tad salīdzini precizitāti, kas iegūta ar vienu izsaukumu, pret pieciem izsaukumiem. Iegūtais skaitlis atrisinās pieskaitāmo izmaksu jautājumu tavā konkrētajā gadījumā – to nespēs izdarīt neviens vispārīgs ieteikums.

Galvenās atziņas

  • Paškonsekvence ģenerē vairākas atbildes un balso par labāko
  • Izmanto temperature > 0, lai panāktu dažādību
  • Efektīva uzdevumiem ar diskrētu atbildi (klasifikācija, aprēķins)
  • Bezjēdzīga radošiem uzdevumiem bez vienas pareizas atbildes
  • Paralēlizē izsaukumus ar asyncio, lai ierobežotu latentumu