Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Selbstkonsistenz: Mehrere Denkpfade

Lektion 6 von 16 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Selbstkonsistenz: Mehrere Denkpfade
  2. Das Problem, das sie löst
  3. Grundlegende Implementierung
  4. Was die Abstimmung Ihnen sagt
  5. Parallelversion mit asyncio
  6. Wann Selbstkonsistenz verwendet werden sollte
  7. Abstimmung des Kosten-/Zuverlässigkeitsverhältnisses
  8. Kernaussagen

Lektion aktualisiert am 3. November 2026 basierend auf der OpenAI-Dokumentation: temperature und top_p werden nur mit einem Denkversuch von none akzeptiert, während GPT-5.6-Modelle standardmäßig denken (medium). Aufrufe, die diese Parameter setzen, müssen daher reasoning={"effort": "none"} (Responses API) oder reasoning_effort="none" (Chat Completions) angeben. Quellen: Using GPT-6 · GPT-5.6 Terra.

Selbstkonsistenz: Mehrere Denkpfade

Selbstkonsistenz umfasst die Generierung mehrerer unabhängiger Antworten auf denselben Prompt, wonach die häufigste oder kohärenteste ausgewählt wird. Das Prinzip ist das Wählen: Ein einziger Aufruf setzt Sie der Zufälligkeit eines schlechten Zuges aus, während fünf Aufrufe Ihnen eine Verteilung bieten, die Sie abfragen können. Diese Technik verbessert die Zuverlässigkeit der Antworten erheblich, insbesondere bei logischem Schlussfolgern und mathematischen Aufgaben.

Das Problem, das sie löst

Ein LLM kann bei jedem Aufruf eine andere Antwort geben, selbst bei einem streng identischen Prompt. Einige dieser Antworten sind korrekt, andere nicht, und nichts in der Ausgabe signalisiert, welche Sie gerade lesen: Eine falsche Antwort wird mit derselben Sicherheit wie eine richtige angegeben. Selbstkonsistenz wendet diese Variabilität zu Ihrem Vorteil. Wenn das Modell über mehrere verschiedene Denkpfade zu derselben Schlussfolgerung gelangt, ist diese wahrscheinlich korrekt; ein Fehler reproduziert sich im Gegensatz dazu selten identisch von einem Zug zum nächsten, da er genau vom gewählten Pfad abhängt.

Grundlegende Implementierung

Der Mechanismus besteht aus drei Schritten: Generieren, Extrahieren der endgültigen Antwort, Wählen. Das Marker-Symbol >>> ANSWER:, das in den Anweisungen durchgesetzt wird, ist nicht kosmetisch – es ist das, was die Ausgabe parsierbar macht, ohne dass die vorangehende Schlussfolgerung interpretiert werden muss. Ohne diesen Anker müssten Sie eine zerbrechliche Heuristik schreiben, um zu erraten, wo die Reflexion endet und die Schlussfolgerung beginnt.

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:
    """Generiert n Antworten und gibt die häufigste zurück."""
    responses = []

    for _ in range(n):
        response = client.responses.create(
            model=model,
            reasoning={"effort": "none"},  # temperature erfordert effort none
            instructions=system + "\nSchließen Sie Schritt für Schritt ab und geben Sie "
                         "ihre endgültige Antwort nach '>>> ANSWER:' an",
            input=prompt,
            temperature=0.7  # Temperatur > 0 für Vielfalt
        )
        responses.append(response.output_text)

    # Extrahieren der endgültigen Antworten
    answers = []
    for r in responses:
        if ">>> ANSWER:" in r:
            answer = r.split(">>> ANSWER:")[-1].strip()
            answers.append(answer)

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

Was die Abstimmung Ihnen sagt

Angewendet auf Sentiment-Klassifizierung gibt die Funktion nicht nur ein Label zurück, sondern eine Verteilung, und diese Verteilung ist oft wertvoller als das Label selbst. Für die folgende Rezension, die wirklich mehrdeutig ist – das Produkt ist in Ordnung, aber die Lieferung war katastrophal – stimmen vier Aufrufe für “negativ” und drei für “neutral”. Die 57%ige Sicherheit sagt Ihnen, dass dieser Fall möglicherweise einer besonderen Behandlung bedarf: Warteschlangeneinrichtung für menschliche Prüfung, Nachfrage beim Benutzer nach Klärung oder einfach Ausschluss aus aggregierten Statistiken. Ein einzelner Aufruf hätte “negativ” ohne Nuance angezeigt, und Sie hätten diesen Ticket genau wie eine einstimmig wütende Rezension behandelt.

system = """Sie sind ein Sentiment-Klassifizierer.
Analysieren Sie den Text und schließen Sie Schritt für Schritt ab.
Geben Sie Ihre endgültige Antwort nach '>>> ANSWER:' an, indem Sie wählen aus:
positive, negative, neutral"""

text = "Das Produkt ist in Ordnung, aber die Lieferung dauerte 3 Wochen."

result = self_consistency(text, system, n=7)
print(f"Sentiment: {result['answer']}")
print(f"Confidence: {result['confidence']:.0%}")
print(f"Distribution: {result['all_answers']}")
# Beispiel-Ausgabe:
# Sentiment: negative
# Confidence: 57%
# Distribution: {'negative': 4, 'neutral': 3}

Parallelversion mit asyncio

Die Kosten dieser Technik sind nicht nur finanziell: Fünf sequenzielle Aufrufe bedeuten auch fünfmal die Latenz, was den Ansatz in jedem Interface ausschließt, in dem jemand auf dem Bildschirm wartet. Dennoch sind die Aufrufe völlig unabhängig; es gibt keinen Grund, auf sie nacheinander zu warten. asyncio.gather bringt die Gesamtzeit auf die des langsamsten Aufrufs, wodurch Selbstkonsistenz mit Online-Nutzung kompatibel wird, wobei die Overhead rein monetär wird.

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

async def self_consistency_async(prompt: str, system: str = "",
                                  n: int = 5) -> dict:
    """Asynchrone Version der Selbstkonsistenz."""

    async def single_call():
        response = await async_client.responses.create(
            model="gpt-5.6-terra",
            reasoning={"effort": "none"},  # temperature erfordert effort none
            instructions=system + "\nSchließen Sie dann Ihre Antwort nach "
                         "'>>> ANSWER:' an",
            input=prompt,
            temperature=0.7
        )
        return response.output_text

    # Starten Sie alle Anfragen parallel
    tasks = [single_call() for _ in range(n)]
    results = await asyncio.gather(*tasks)

    # Extrahieren und wählen
    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)
    }

Wann Selbstkonsistenz verwendet werden sollte

Das Entscheidungskriterium ist einfach zu formulieren: Wählen macht nur Sinn, wenn die Antwort diskret und vergleichbar ist. Zwei gut geschriebene Zusammenfassungen können nicht abgestimmt werden, da sie niemals buchstabenidentisch sein werden; zwei Kategorienschilder schon.

Anwendungsfall Nützlich? Warum
Klassifizierung Ja Diskrete Antwort, einfache Abstimmung
Mathematisches Schlussfolgern Ja Mehrere Pfade zur richtigen Antwort
Entitätsextraktion Ja Konsens über erkannte Entitäten
Kreatives Schreiben Nein Keine einzelne "korrekte" Antwort
Textzusammenfassung Teilweise Nützlich für Schlüsselinformationen, nicht für Stil

Abstimmung des Kosten-/Zuverlässigkeitsverhältnisses

Drei Aufrufe sind die minimal lebensfähige Anzahl, damit eine Mehrheitsabstimmung überhaupt etwas bedeutet; fünf bietet den besten Kompromiss für die meisten Anwendungen; sieben bis elf sind für kritische Entscheidungen gerechtfertigt, bei denen ein Fehler weit mehr kostet als einige zusätzliche Aufrufe. Der eigentliche Gewinn kommt jedoch davon, wie Sie den Sicherheitswert verwenden, nicht von der Stichprobengröße. Unter 60% gehen Sie davon aus, dass es keinen Konsens gibt, und eskalieren entweder auf einen menschlichen Operator oder auf ein leistungsfähigeres Modell mit mehr Stichproben, wie unten gezeigt.

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

if result["confidence"] < 0.6:
    # Kein klarer Konsens, eskalieren
    result = self_consistency(question, system, n=9, model="gpt-5.6-sol")

Die verbleibende Frage ist, ob der Saft den Schweiß in Ihrem spezifischen Fall wert ist, und das muss gemessen werden, nicht angenommen. Implementieren Sie die asynchrone Version, führen Sie sie auf ein Dutzend Sentiment-Klassifizierungsfragen durch, bei denen Sie die erwartete Antwort kennen, und vergleichen Sie die erzielte Genauigkeit mit einem einzelnen Aufruf versus fünf Aufrufen. Die Zahl, die Sie erhalten, wird die Frage der Overhead für Ihren spezifischen Fall klären, etwas, das keine allgemeine Empfehlung für Sie tun kann.

Kernaussagen

  • Selbstkonsistenz generiert mehrere Antworten und wählt die beste aus
  • Verwenden Sie eine Temperatur > 0, um Vielfalt zu erreichen
  • Effektiv für Aufgaben mit einer diskreten Antwort (Klassifizierung, Berechnung)
  • Nutzlos für kreative Aufgaben ohne eine einzelne korrekte Antwort
  • Parallelisieren Sie Aufrufe mit asyncio, um Latenz zu begrenzen