Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Selvkonsistens: Flere ræsonnementsveje

Lektion 6 af 16 Opdateret 3. november 2026 Udvikler
På denne side
  1. Selvkonsistens: Flere ræsonnementsveje
  2. Problemet det løser
  3. Grundlæggende implementering
  4. Hvad afstemningen fortæller dig
  5. Parallel version med asyncio
  6. Hvornår skal du bruge selvkonsistens?
  7. Justering af forholdet mellem omkostninger og pålidelighed
  8. Vigtige pointer

Lektion opdateret 3. november 2026 baseret på OpenAI-dokumentation: temperature og top_p accepteres kun med en ræsonnementsindsats på none, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificere reasoning={"effort": "none"} (Responses API) eller reasoning_effort="none" (Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.

Selvkonsistens: Flere ræsonnementsveje

Selvkonsistens går ud på at generere flere uafhængige svar på den samme prompt og derefter vælge det hyppigste eller mest sammenhængende. Princippet er afstemning: Et enkelt kald udsætter dig for tilfældigheden ved et dårligt træk, mens fem kald giver dig en fordeling, du kan spørge ind til. Denne teknik forbedrer svarpåliteligheden markant, især ved logisk ræsonnement og matematiske opgaver.

Problemet det løser

En LLM kan give et andet svar ved hvert kald, selv med en strengt identisk prompt. Nogle af disse svar er korrekte, andre er ikke, og intet i outputtet signalerer, hvilket du læser: Et forkert svar fremsættes med samme selvsikkerhed som et rigtigt. Selvkonsistens vender denne variabilitet til din fordel. Hvis modellen når frem til samme konklusion via flere forskellige ræsonnementsveje, er den konklusion sandsynligvis korrekt; en fejl derimod reproduceres sjældent identisk fra træk til træk, fordi den netop afhænger af den vej, der blev taget.

Grundlæggende implementering

Mekanismen har tre trin: generér, udtræk det endelige svar, stem. Markøren >>> ANSWER: håndhævet i instruktionerne er ikke kosmetisk – det er det, der gør outputtet parserbart uden at skulle fortolke ræsonnementet, der går forud. Uden dette anker ville du skulle skrive en skrøbelig heuristik for at gætte, hvor refleksionen slutter, og konklusionen begynder.

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:
    """Genererer n svar og returnerer det hyppigste."""
    responses = []

    for _ in range(n):
        response = client.responses.create(
            model=model,
            reasoning={"effort": "none"},  # temperature kræver effort none
            instructions=system + "\nRæsonnér trin for trin, og giv derefter "
                         "dit endelige svar efter '>>> ANSWER:'",
            input=prompt,
            temperature=0.7  # Temperatur > 0 for diversitet
        )
        responses.append(response.output_text)

    # Udtræk endelige svar
    answers = []
    for r in responses:
        if ">>> ANSWER:" in r:
            answer = r.split(">>> ANSWER:")[-1].strip()
            answers.append(answer)

    # Majoritetsafstemning
    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}

Hvad afstemningen fortæller dig

Anvendt på sentimentklassificering returnerer funktionen ikke bare en label, men en fordeling, og den fordeling er ofte mere værdifuld end selve labelen. For anmeldelsen nedenfor, som er ægte tvetydig – produktet er fint, men leveringen var katastrofal – stemmer fire kald på “negativt” og tre på “neutralt”. De 57 % konfidens fortæller dig, at denne sag måske fortjener særlig behandling: kø til menneskelig gennemgang, anmodning om afklaring fra brugeren eller simpelthen udelukkelse fra aggregerede statistikker. Et enkelt kald ville have vist “negativt” uden nuancer, og du ville have behandlet denne sag præcis som en enstemmigt rasende anmeldelse.

system = """Du er en sentiment-klassificator.
Analyser teksten og ræsonnér trin for trin.
Giv dit endelige svar efter '>>> ANSWER:' valgt blandt:
positive, negative, neutral"""

text = "Produktet er fint, men leveringen tog 3 uger."

result = self_consistency(text, system, n=7)
print(f"Sentiment: {result['answer']}")
print(f"Konfidens: {result['confidence']:.0%}")
print(f"Forseling: {result['all_answers']}")
# Eksempel på output:
# Sentiment: negative
# Konfidens: 57%
# Forseling: {'negative': 4, 'neutral': 3}

Parallel version med asyncio

Omkostningen ved denne teknik er ikke kun finansiel: Fem sekventielle kald betyder også fem gange så stor latens, hvilket udelukker tilgangen i enhver grænseflade, hvor nogen venter ved deres skærm. Alligevel er kaldene fuldstændig uafhængige; der er ingen berettigelse til at vente på dem ét efter ét. asyncio.gather bringer den samlede tid ned til det langsomste kald, hvilket gør selvkonsistens kompatibel med online-brug, med et overhead der bliver rent monetært.

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

async def self_consistency_async(prompt: str, system: str = "",
                                  n: int = 5) -> dict:
    """Asynkron version af selvkonsistens."""

    async def single_call():
        response = await async_client.responses.create(
            model="gpt-5.6-terra",
            reasoning={"effort": "none"},  # temperature kræver effort none
            instructions=system + "\nRæsonnér og giv derefter dit svar "
                         "efter '>>> ANSWER:'",
            input=prompt,
            temperature=0.7
        )
        return response.output_text

    # Start alle anmodninger parallelt
    tasks = [single_call() for _ in range(n)]
    results = await asyncio.gather(*tasks)

    # Udtræk og stem
    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)
    }

Hvornår skal du bruge selvkonsistens?

Beslutningskriteriet er enkelt at formulere: Afstemning giver kun mening, hvis svaret er diskret og sammenligneligt. To velskrevne resuméer kan ikke tælles sammen, da de aldrig vil være identiske tegn for tegn; to kategorilabels kan.

Use Case Nyttigt? Hvorfor
Klassificering Ja Diskret svar, simpel afstemning
Matematisk ræsonnement Ja Flere veje til det korrekte svar
Entitetsudtrækning Ja Konsensus om registrerede entiteter
Kreativ skrivning Nej Intet enkelt "korrekt" svar
Tekstresumé Delvist Nyttigt for nøglefakta, ikke stil

Justering af forholdet mellem omkostninger og pålidelighed

Tre kald er det mindste levedygtige antal for, at en majoritetsafstemning skal betyde noget; fem tilbyder det bedste kompromis for de fleste applikationer; syv til elleve er berettiget ved kritiske beslutninger, hvor en fejl koster langt mere end et par ekstra kald. Den virkelige gevinst kommer dog af, hvordan du bruger konfidensscoren snarere end antallet af prøver. Under 60 % bør du betragte det som manglende konsensus og eskalere, enten til en menneskelig operatør eller til en mere kraftfuld model med flere prøver, som vist nedenfor.

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

if result["confidence"] < 0.6:
    # Ingen klar konsensus, eskaler
    result = self_consistency(question, system, n=9, model="gpt-5.6-sol")

Det tilbageværende spørgsmål er, om det kan betale sig i dit specifikke tilfælde, og det skal måles, ikke antages. Implementér den asynkrone version, kør den på et dusin spørgsmål om sentimentklassificering, hvor du kender det forventede svar, og sammenlign derefter nøjagtigheden opnået med et enkelt kald kontra fem kald. Tallet, du får, vil afgøre spørgsmålet om overhead for dit specifikke tilfælde, noget ingen generel anbefaling kan gøre for dig.

Vigtige pointer

  • Selvkonsistens genererer flere svar og stemmer om det bedste
  • Brug en temperatur > 0 for at opnå diversitet
  • Effektivt til opgaver med et diskret svar (klassificering, beregning)
  • Nytteløst til kreative opgaver uden et enkelt korrekt svar
  • Parallelisér kald med asyncio for at begrænse latens