Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Självkonsistens: Flera resonemangsvägar

Lektion 6 av 16 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Självkonsistens: Flera resonemangsvägar
  2. Problemet det löser
  3. Grundläggande implementering
  4. Vad omröstningen berättar för dig
  5. Parallell version med asyncio
  6. När du ska använda självkonsistens
  7. Justera förhållandet mellan kostnad och tillförlitlighet
  8. Viktiga punkter

Lektionen uppdaterad 3 november 2026 baserat på OpenAI-dokumentation: temperature och top_p accepteras endast med ett resonemangsarbete på none, medan GPT-5.6-modeller resonerar som standard (medium). Anrop som ställer in dessa parametrar måste därför specificera reasoning={"effort": "none"} (Responses API) eller reasoning_effort="none" (Chat Completions). Källor: Använda GPT-6 · GPT-5.6 Terra.

Självkonsistens: Flera resonemangsvägar

Självkonsistens innebär att generera flera oberoende svar på samma prompt och sedan välja det som förekommer oftast eller är mest sammanhängande. Principen bygger på omröstning: ett enskilt anrop utsätter dig för slumpen i ett dåligt drag, medan fem anrop ger dig en fördelning du kan fråga. Denna teknik förbättrar svarstillförlitligheten avsevärt, särskilt för logiskt resonemang och matematiska uppgifter.

Problemet det löser

En LLM kan ge ett annat svar vid varje anrop, även med en strikt identisk prompt. Vissa av dessa svar är korrekta, andra inte, och inget i utdata signalerar vilket du läser: ett felaktigt svar framförs med samma självförtroende som ett rätt. Självkonsistens vänder denna variabilitet till din fördel. Om modellen når samma slutsats via flera olika resonemangsvägar är den slutsatsen sannolikt korrekt; ett fel återskapas däremot sällan identiskt från ett drag till nästa eftersom det beror just på den väg som togs.

Grundläggande implementering

Mekanismen har tre steg: generera, extrahera det slutgiltiga svaret, rösta. Markören >>> ANSWER: som tvingas fram i instruktionerna är inte kosmetisk – det är det som gör utdatan parserbar utan att behöva tolka resonemanget som föregår den. Utan denna ankare skulle du behöva skriva en bräcklig heuristik för att gissa var reflektionen slutar och slutsatsen börjar.

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:
    """Genererar n svar och returnerar det vanligaste."""
    responses = []

    for _ in range(n):
        response = client.responses.create(
            model=model,
            reasoning={"effort": "none"},  # temperature kräver effort none
            instructions=system + "\nResonera steg för steg, ge sedan "
                         "ditt slutgiltiga svar efter '>>> ANSWER:'",
            input=prompt,
            temperature=0.7  # Temperatur > 0 för mångfald
        )
        responses.append(response.output_text)

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

    # Majoritetsomröstning
    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}

Vad omröstningen berättar för dig

När den appliceras på sentimentklassificering returnerar funktionen inte bara en etikett utan en fördelning, och den fördelningen är ofta mer värdefull än själva etiketten. För recensionen nedan, som är genuint tvetydig – produkten är bra, men leveransen var katastrofal – röstar fyra anrop på “negativt” och tre på “neutralt”. Konfidensen på 57 % berättar att detta fall kan förtjäna särskild hantering: köa för mänsklig granskning, be användaren om förtydligande, eller helt enkelt exkludera det från aggregerad statistik. Ett enskilt anrop hade visat “negativt” utan nyanser, och du hade behandlat detta ärende exakt som en enhälligt rasande recension.

system = """Du är en sentimentklassificerare.
Analysera texten och resonera steg för steg.
Ge ditt slutgiltiga svar efter '>>> ANSWER:' genom att välja från:
positive, negative, neutral"""

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

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

Parallell version med asyncio

Kostnaden för denna teknik är inte bara ekonomisk: fem sekventiella anrop betyder också fem gånger latensen, vilket utesluter tillvägagångssättet i alla gränssnitt där någon väntar vid sin skärm. Ändå är anropen helt oberoende; det finns ingen motivering att vänta på dem ett efter ett. asyncio.gather sänker den totala tiden till den för det långsammaste anropet, vilket gör självkonsistens kompatibel med onlineanvändning, med ett överhead som blir 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 av självkonsistens."""

    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 + "\nResonera och ge sedan ditt svar "
                         "efter '>>> ANSWER:'",
            input=prompt,
            temperature=0.7
        )
        return response.output_text

    # Starta alla förfrågningar parallellt
    tasks = [single_call() for _ in range(n)]
    results = await asyncio.gather(*tasks)

    # Extrahera och rösta
    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)
    }

När du ska använda självkonsistens

Beslutskriteriet är enkelt att uttrycka: omröstning är bara meningsfullt om svaret är diskret och jämförbart. Två välskrivna sammanfattningar kan inte räknas ihop, eftersom de aldrig kommer att vara tecken-för-tecken identiska; två kategorietiketter kan det.

Användningsområde Användbart? Varför
Klassificering Ja Diskret svar, enkel omröstning
Matematiskt resonemang Ja Flera vägar till rätt svar
Entitetsutvinning Ja Konsensus om identifierade entiteter
Kreativt skrivande Nej Inget enskilt "rätt" svar
Textsammanfattning Delvis Användbart för nyckelfakta, inte stil

Justera förhållandet mellan kostnad och tillförlitlighet

Tre anrop är det minsta möjliga antalet för att en majoritetsomröstning ska betyda något; fem erbjuder den bästa kompromissen för de flesta applikationer; sju till elva är motiverade för kritiska beslut, där ett fel kostar långt mer än några extra anrop. Den verkliga vinsten kommer dock från hur du använder konfidenspoängen snarare än antalet stickprov. Under 60 %, anse att det inte finns någon konsensus och eskalera, antingen till en mänsklig operatör eller till en kraftfullare modell med fler stickprov, enligt nedan.

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

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

Återstående fråga är om mödan lönar sig i ditt specifika fall, och det måste mätas, inte antas. Implementera den asynkrona versionen, kör den på ett dussin frågor om sentimentklassificering där du känner till det förväntade svaret, och jämför sedan noggrannheten som erhålls med ett enskilt anrop kontra fem anrop. Siffran du får kommer att avgöra frågan om överhead för ditt specifika fall, något ingen generell rekommendation kan göra åt dig.

Viktiga punkter

  • Självkonsistens genererar flera svar och röstar fram det bästa
  • Använd en temperatur > 0 för att uppnå mångfald
  • Effektivt för uppgifter med ett diskret svar (klassificering, beräkning)
  • Användningslöst för kreativa uppgifter utan ett enda rätt svar
  • Parallellisera anrop med asyncio för att begränsa latens