Self-Consistency

Einfach erklärt

Self-Consistency verbessert LLM-Antworten, indem mehrere Antworten generiert und die häufigste gewählt wird. Statt einer Antwort zu vertrauen, nutzt du die “Weisheit der Masse” – aus demselben Modell.

Der Prozess:

Frage: "Was ist 17 × 24?"

Sample 1: "17 × 24 = 17 × 20 + 17 × 4 = 340 + 68 = 408" ✓
Sample 2: "17 × 24 = 400 + 8 = 408" ✓
Sample 3: "17 × 24 = 17 × 25 - 17 = 425 - 17 = 408" ✓
Sample 4: "17 × 24 = 20 × 24 - 3 × 24 = 480 - 72 = 408" ✓
Sample 5: "17 × 24 = 17 × 24 = 388" ✗ (Rechenfehler)

Majority Vote: 408 (4 von 5)
→ Finale Antwort: 408

Warum funktioniert das?

Szenario	Einzelne Antwort	Self-Consistency
Richtige Antwort	80% Chance	95%+ Chance
Halluzination	Möglich	Unwahrscheinlich (inkonsistent)
Rechenfehler	Möglich	Wird überstimmt

Technischer Deep Dive

Implementierung

Einfache Version:

def self_consistency(prompt, model, n_samples=5):
    answers = []
    
    for _ in range(n_samples):
        response = model.generate(
            prompt,
            temperature=0.7  # Varianz für unterschiedliche Pfade
        )
        answer = extract_final_answer(response)
        answers.append(answer)
    
    # Majority Vote
    from collections import Counter
    most_common = Counter(answers).most_common(1)[0][0]
    
    return most_common

Mit OpenAI API:

response = openai.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt}],
    n=5,  # 5 Samples in einem Call
    temperature=0.7
)

answers = [choice.message.content for choice in response.choices]

Temperatur-Einstellung

Temperatur	Effekt	Für Self-Consistency
0.0	Deterministisch	❌ Alle Antworten gleich
0.5-0.7	Moderate Varianz	✓ Ideal
1.0+	Hohe Varianz	⚠️ Zu viel Rauschen

Warum nicht Temperatur 0? Bei T=0 sind alle Samples identisch – kein Voting möglich. Varianz ist nötig, um verschiedene Reasoning-Pfade zu explorieren.

Weighted Voting

Statt einfachem Majority Vote können Antworten gewichtet werden:

def weighted_consistency(prompt, model, n_samples=5):
    answers_with_confidence = []
    
    for _ in range(n_samples):
        response = model.generate(prompt, return_logprobs=True)
        answer = extract_answer(response)
        confidence = calculate_confidence(response.logprobs)
        answers_with_confidence.append((answer, confidence))
    
    # Gewichtetes Voting
    weighted_votes = defaultdict(float)
    for answer, confidence in answers_with_confidence:
        weighted_votes[answer] += confidence
    
    return max(weighted_votes, key=weighted_votes.get)

Wann Self-Consistency nutzen?

Gut geeignet:

• Mathematische Probleme
• Logik-Rätsel
• Faktenfragen mit eindeutiger Antwort
• Code mit klarem Output

Weniger geeignet:

• Kreative Aufgaben (keine “richtige” Antwort)
• Offene Fragen
• Subjektive Bewertungen

Konsistenz als Konfidenz-Maß

def consistency_score(answers):
    """
    Wie einig sind sich die Samples?
    1.0 = alle gleich, 0.0 = alle unterschiedlich
    """
    from collections import Counter
    counts = Counter(answers)
    most_common_count = counts.most_common(1)[0][1]
    return most_common_count / len(answers)

# Beispiel
answers = ["408", "408", "408", "408", "388"]
score = consistency_score(answers)  # 0.8

if score < 0.5:
    print("Warnung: Niedrige Konsistenz, Antwort unsicher")

Kosten-Optimierung

Strategie	Beschreibung
Adaptive Sampling	Starte mit 3, erhöhe bei niedriger Konsistenz
Early Stopping	Stoppe wenn 3 von 5 übereinstimmen
Kleineres Modell	Für Samples kleineres Modell, für Final größeres
Batch Requests	n-Parameter statt einzelne Calls