0Pricing
AI Prompt Engineering · Lektion

Self-Consistency-Sampling

Über mehrere Schlussfolgerungspfade abstimmen

Self-Consistency-Sampling ist eine kostenlose AI Prompt Engineering-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Prompt Engineering-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.

Eine einzelne Kette ist fragil

Eine einzelne Chain-of-Thought kann früh falsch abbiegen und sich danach nicht mehr erholen. Die Selbstkonsistenz (Wang et al., 2022) begegnet diesem Problem, indem sie viele unabhängige Reasoning-Pfade erzeugt und deren Endantworten zusammenfasst, typischerweise durch Mehrheitsentscheidung.

Die Intuition dahinter: Korrektes Reasoning führt über unterschiedliche Wege zur selben Antwort, während sich Fehler verstreuen. Die Aggregation verstärkt das konsistente Signal.

def self_consistency(prompt, n=20, temperature=0.7):
    answers = []
    for _ in range(n):
        chain = llm(prompt, temperature=temperature)
        answers.append(extract_answer(chain))
    return majority_vote(answers)

Warum die Marginalisierung über Pfade funktioniert

Selbstkonsistenz approximiert die Marginalisierung über Reasoning-Pfade: Statt einer einzigen latenten Herleitung zu vertrauen, schätzen Sie die wahrscheinlichste Endantwort, integriert über viele Herleitungen.

Dies ist eine Monte-Carlo-Schätzung der Antwortverteilung. Der Modus dieser Verteilung ist normalerweise zuverlässiger als jeder einzelne Stichprobenpfad, insbesondere wenn der Antwortbereich klein und diskret ist.

from collections import Counter

def majority_vote(answers):
    norm = [normalize_answer(a) for a in answers]
    counts = Counter(norm)
    answer, votes = counts.most_common(1)[0]
    confidence = votes / len(norm)
    return answer, confidence

Vielfalt durch die Temperatur

Selbstkonsistenz benötigt vielfältige Pfade. Greedy-Verfahren oder eine Temperatur nahe null erzeugen nahezu identische Ketten und machen die Methode wirkungslos. Verwenden Sie eine moderate Temperatur (häufig 0.5 bis 0.8) und gegebenenfalls Top-p-Sampling, um die Pfade stärker zu verteilen.

Eine zu hohe Temperatur verschlechtert jede einzelne Kette. Stimmen Sie die Temperatur so ab, dass die Genauigkeit des Ensembles maximiert wird, nicht die Qualität einer einzelnen Kette.

def tune_temperature(prompt, val_set, temps=(0.4, 0.6, 0.8, 1.0)):
    best = max(
        temps,
        key=lambda t: ensemble_accuracy(prompt, val_set, temp=t, n=20)
    )
    return best

Die Normalisierung von Antworten ist entscheidend

Stimmen zählen nur, wenn gleichwertige Antworten als gleich erkannt werden. Normalisieren Sie vor dem Zählen: Entfernen Sie Einheiten, kanonisieren Sie Zahlen, wandeln Sie Text in Kleinschreibung um, parsen Sie Brüche und Prozentangaben und wenden Sie aufgabenspezifische Gleichwertigkeitsregeln an.

Eine schlechte Normalisierung verteilt die tatsächliche Mehrheit auf verschiedene Oberflächenvarianten und lässt eine Minderheitsantwort die Abstimmung gewinnen.

def normalize_answer(a):
    a = a.strip().lower().rstrip('.')
    a = a.replace(',', '').replace('$', '').replace('%', '')
    try:
        return str(round(float(a), 6))   # numeric canonical form
    except ValueError:
        return a

Wie viele Stichproben?

Die Genauigkeit steigt mit der Anzahl der Stichproben n, allerdings mit abnehmendem Grenznutzen, und erreicht je nach Aufgabenschwierigkeit häufig bei 10 bis 40 ein Plateau. Jede Stichprobe erhöht Kosten und Latenz linear.

Testen Sie verschiedene Werte für n auf einem Validierungssatz und wählen Sie den Knickpunkt der Kurve, an dem zusätzliche Stichproben ihre Kosten nicht mehr rechtfertigen.

def sweep_n(prompt, val, ns=(1,3,5,10,20,40)):
    return {n: ensemble_accuracy(prompt, val, n=n) for n in ns}
# Choose n at the accuracy/cost knee, not the maximum

Adaptives frühzeitiges Beenden

Sparen Sie Rechenaufwand durch adaptives Sampling: Beenden Sie die Erzeugung von Pfaden, sobald die Abstimmung eindeutig ist. Wenn eine Antwort nach 5 Stichproben deutlich führt, werden weitere Stichproben den Sieger wahrscheinlich nicht mehr ändern.

So konzentrieren Sie den Rechenaufwand auf tatsächlich schwierige, umstrittene Aufgaben und beantworten einfache Aufgaben kostengünstig.

def adaptive_sc(prompt, max_n=40, margin=0.6, min_n=5):
    answers = []
    for i in range(max_n):
        answers.append(extract_answer(llm(prompt, temperature=0.7)))
        if i + 1 >= min_n:
            ans, conf = majority_vote(answers)
            if conf >= margin:
                return ans, conf, i + 1
    return majority_vote(answers)

Gewichtete und verifiergestützte Abstimmung

Bei einer einfachen Mehrheitsentscheidung werden alle Pfade gleich behandelt. Sie können Stimmen nach der vom Modell zugewiesenen Wahrscheinlichkeit eines Pfads, nach dem Score eines trainierten Verifiers oder anhand einer Selbsteinschätzung der Gültigkeit jeder Kette gewichten.

Verifiergewichtete Selbstkonsistenz ist bei der Abstimmung ohne Gewichtung häufig überlegen, weil sie selbstsichere, aber falsche und häufige Fehlermuster abwertet.

def weighted_vote(chains):
    scores = {}
    for c in chains:
        a = normalize_answer(extract_answer(c))
        scores[a] = scores.get(a, 0.0) + verifier_score(c)
    return max(scores, key=scores.get)

Konfidenz durch Übereinstimmung

Der Stimmenabstand ist ein nützliches Konfidenzsignal. Eine einstimmige Antwort ist wesentlich vertrauenswürdiger als eine Aufteilung von 6 zu 5. Stellen Sie dieses Signal nachgelagerter Logik zur Verfügung: Leiten Sie Aufgaben mit geringer Übereinstimmung an eine Eskalationsstufe, eine menschliche Prüfung oder ein stärkeres Modell weiter.

So wird Selbstkonsistenz sowohl zu einer Methode zur Genauigkeitssteigerung als auch zu einem Kalibrierungsmechanismus.

def route(prompt):
    ans, conf = adaptive_sc(prompt)[:2]
    if conf < 0.5:
        return escalate_to_stronger_model(prompt)
    return ans

Grenzen: kontinuierliche und offene Aufgaben

Mehrheitsentscheidungen setzen einen diskreten, vergleichbaren Antwortbereich voraus. Sie lassen sich nicht direkt auf freie Textgenerierung, lange Texte oder kontinuierliche Ausgaben anwenden, bei denen keine zwei Stichproben identisch sind.

Aggregieren Sie für solche Aufgaben anders: Clustern Sie semantisch ähnliche Ausgaben, stimmen Sie über extrahierte strukturierte Felder ab oder verwenden Sie ein Judge-Modell, um die beste Stichprobe auszuwählen, statt exakte Übereinstimmungen zu zählen.

def semantic_consistency(samples):
    clusters = cluster_by_embedding(samples)
    biggest = max(clusters, key=len)        # largest agreement cluster
    return representative(biggest)            # medoid of the cluster

Kostenbewusster Einsatz

Selbstkonsistenz gehört zu den teuersten Prompting-Techniken: Die Kosten steigen mit n. Reservieren Sie sie für wichtige oder schwierige Aufgaben, kombinieren Sie sie mit adaptivem Beenden und erwägen Sie eine abgestufte Strategie, bei der eine einzelne Kette einfache Anfragen bearbeitet.

Vergleichen Sie immer die Genauigkeit pro Euro mit einem einzelnen Aufruf eines stärkeren Modells, der für denselben Zugewinn möglicherweise günstiger ist.

def tiered(prompt, q):
    if easy(q):
        return extract_answer(llm(prompt, temperature=0))
    return adaptive_sc(prompt, max_n=20)[0]   # SC only when needed

Selbstkonsistenz von Anfang bis Ende

Eine vollständige Pipeline: Stimmen Sie Temperatur und n ab, erzeugen Sie vielfältige Ketten, normalisieren Sie Antworten rigoros, führen Sie eine Abstimmung durch (optional verifiergewichtet), verwenden Sie den Stimmenabstand als Konfidenzmaß, beenden Sie die Verarbeitung frühzeitig, sobald das Ergebnis eindeutig ist, und eskalieren Sie Aufgaben mit geringer Übereinstimmung.

Das Ergebnis ist ein Reasoning-System, das genauer und besser selbstkalibriert ist als jede einzelne Kette.

def solve(prompt):
    chains = sample_until_decisive(prompt, max_n=20, temp=0.7)
    ans, conf = weighted_majority(chains)
    if conf < THRESH:
        return escalate(prompt)
    return {'answer': ans, 'confidence': conf, 'paths': len(chains)}

Kurztest

Diagnostizieren Sie eine Selbstkonsistenz-Konfiguration, die schlechter als erwartet abschneidet.

Zusammenfassung

Wichtigste Erkenntnisse:

  • Selbstkonsistenz erzeugt viele vielfältige Ketten und stimmt über deren Ergebnisse ab, wodurch die Marginalisierung über Reasoning-Pfade approximiert wird.
  • Vielfalt (moderate Temperatur) und rigorose Antwortnormalisierung sind Voraussetzungen für das Funktionieren der Methode.
  • Die Genauigkeit steigt mit n, erreicht aber ein Plateau. Verwenden Sie adaptives frühzeitiges Beenden, um die Kosten zu kontrollieren.
  • Gewichten Sie Stimmen mit einem Verifier und verwenden Sie den Stimmenabstand als kalibriertes Konfidenzsignal.
  • Die Methode benötigt einen diskreten Antwortbereich. Clustern Sie bei offenen Aufgaben semantisch ähnliche Antworten oder verwenden Sie ein Judge-Modell.

Häufig gestellte Fragen

Ist die Lektion „Self-Consistency-Sampling“ kostenlos?

Ja — der vollständige Text von „Self-Consistency-Sampling“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Prompt Engineering-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Self-Consistency-Sampling“?

Über mehrere Schlussfolgerungspfade abstimmen Du übst AI Prompt Engineering mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Prompt Engineering zu starten?

Keine Vorkenntnisse erforderlich. AI Prompt Engineering auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Self-Consistency-Sampling“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Prompt Engineering-Lektion Code schreiben und ausführen?

Ja. Jede AI Prompt Engineering-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Chain-of-Thought-Prompting
  2. Self-Consistency-Sampling
  3. Tree-of-Thought-Exploration
  4. Wann Reasoning-Prompts helfen
← Zurück zu AI Prompt Engineering