Paškonsekvence: vairāki spriešanas ceļi
Šajā lapā
Nodarbība atjaunināta 2026. gada 3. novembrī, pamatojoties uz OpenAI dokumentāciju: parametri
temperatureuntop_ptiek pieņemti tikai ar spriešanas piepūlinone, 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ādareasoning={"effort": "none"}(Responses API) vaireasoning_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