Chain-of-Thought Prompting

Frage: "Ich habe 10 Äpfel. Ich esse 3. Meine Freundin gibt mir 5.
        Wie viele habe ich jetzt?"

Model ohne CoT (Direct):
Antwort: "Du hast 12 Äpfel"
Richtig! Aber...

Bei komplexeren Problemen:
Frage: "Ein Zug fährt von A nach B (200km) mit 100km/h.
        Ein Auto fährt von B nach A mit 80km/h.
        Sie starten gleichzeitig. Wann treffen sie sich?"

Model: "Sie treffen sich nach 2 Stunden"
Falsch! (Richtig: ~1.1 Stunden)
Grund: Modell hat nicht wirklich "gedacht", sondern geraten

Frage: "...Wann treffen sie sich?
        Lass mich schritt-für-schritt denken."

Model mit CoT:
"Lass mich das durchdenken:
1. Der Zug fährt mit 100 km/h von A nach B
2. Das Auto fährt mit 80 km/h von B nach A
3. Sie treffen sich wenn die Summe ihrer Distanzen 200km ist
4. In Zeit t: Zug fährt 100t km, Auto fährt 80t km
5. 100t + 80t = 200
6. 180t = 200
7. t = 200/180 = 1.11 Stunden

Sie treffen sich nach ~1 Stunde und 7 Minuten"
Richtig!

# Falsch
prompt = "Frage: X. Antwort:"

# Richtig
prompt = """Frage: X

Lass mich Schritt-für-Schritt denken:"""

# Empirisch: +5-40% Accuracy (je nach Task)
# Cost: Mehr Output Tokens (aber billiger als Fehler!)

Das Token "Lass mich ... denken:"
triggert eine andere "mode" im Modell.
Modell nutzt eher "reasoning" pathways
statt "pattern matching" pathways.

# Mit Exemplaren
prompt = """
Exemplar 1:
Frage: 2+2?
Gedanke: 2+2 = 4
Antwort: 4

Exemplar 2:
Frage: 10+15?
Gedanke: 10+15 = 25
Antwort: 25

Neue Frage: 123+456?
Gedanke: [Modell generiert Gedanken]
Antwort: [Modell generiert Antwort]
"""

# Empirisch: +10-50% vs Zero-Shot CoT

def self_consistent_answer(question, num_tries=5):
    answers = []
    for i in range(num_tries):
        response = llm(f"{question}\n\nLass mich denken:")
        # Extract final answer from CoT
        answer = extract_answer(response)
        answers.append(answer)

    # Voting: Welche Antwort kam am häufigsten?
    most_common = max(set(answers), key=answers.count)
    return most_common

# Kosten: 5× mehr Tokens
# Qualität: +5-15% Accuracy
# Nutzen nur für kritische Entscheidungen!

Problem: Welches ist die beste Schach-Strategie?

Thought 1: Angreife König
  Subthought 1.1: Mit Ritter
  Subthought 1.2: Mit Bauer
    Verdict: 1.2 ist besser (wird gedacht)

Thought 2: Verteidige
  Subthought 2.1: Mit Turm
  Subthought 2.2: Mit Läufer

Thought 3: Tausch-Strategie
  ...

Final Decision: Baue einen Suchbaum, nutze LLM um zu bewerten
               welcher Path am vielversprechend ist

response = client.messages.create(
    model="claude-3-7-sonnet",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # Wieviel Zeit zum Denken?
    },
    messages=[{
        "role": "user",
        "content": "Komplexes mathematisches Problem..."
    }]
)

# Claude nutzt 10K Tokens zum "nachdenken"
# Output ist noch präziser als CoT!

Komplexe mathematische Probleme: ✅ CoT +40%
Multi-Step Reasoning: ✅ CoT +30%
Code Writing: ✅ CoT +25%
Logische Rätsel: ✅ CoT +50%

einfache Fragen ("Was ist die Hauptstadt von Frankreich?"): ❌ CoT hilft 0%
                                                           aber +100 Tokens Kosten!

Summarization (die Antwort soll kurz sein): ❌ CoT erzeugt Blabla
                                              Modell sollte direkt zusammenfassen

Klassifikation (nur Label, keine Erklärung): ❌ CoT verschlimmert (==> längere Output)

Sentiment-Analyse (ja/nein/neutral): ❌ CoT overkill

Math Problem (1 shot, no CoT):
- Tokens: 200
- Accuracy: 65%
- Cost: €0.006

Math Problem (1 shot, with CoT):
- Tokens: 600 (mehr output)
- Accuracy: 92%
- Cost: €0.018

"Error Cost" bei 65% vs 92%:
- Error Rate 1: 35% Fehler
- Error Rate 2: 8% Fehler
- Fehlerreduktion: 77%
- Extra Cost: €0.012
- Value wenn Critical: Einfach Worth it!

Rule of Thumb:
Wenn Error teuer ist (Medizin, Code, Finance): CoT immer verwenden
Wenn Fehler billig ist (UI Text): Meistens nicht nötig

# 1. Trigger Richtig
falsch = "Was ist die Antwort?"
richtig = "Lass mich schritt-für-schritt denken:"

# 2. Kombiniere mit Few-Shot
prompt = """
Exemplar 1: [Mit CoT Gedanken]
Exemplar 2: [Mit CoT Gedanken]
Neue Frage:
Lass mich denken:"""

# 3. Nicht zu viele Schritte in Exemplaren
zu_viel = """Gedanke: Schritt 1... Schritt 2... Schritt 3... [50 Zeilen]"""
perfekt = """Gedanke: Zuerst A, dann B, dann C"""

# 4. Struktur für komplexe Tasks
prompt = """
Analysiere:
1. Gegeben:
2. Gesucht:
3. Lösung:
"""

# 5. Nutze Self-Consistency für kritische Decisions
if critical:
    answer = self_consistent_answer(question, num_tries=5)
else:
    answer = llm(question + "\nDenken:")

Q: Ein Zug fährt von A nach B (200km, 100km/h).
   Ein Auto: B nach A (80km/h).
   Wann treffen sie sich?

A: "Sie treffen sich nach 2 Stunden"

Ergebnis: FALSCH (sollte 1.11h sein)
Accuracy: 25% (nur 5 von 20 richtig)
Tokens: 200 (Input) + 50 (Output) = 250 total
Cost: €0.004

Q: [Gleiche Frage]
   Lass mich Schritt-für-Schritt denken:

A: "Lass mich denken:
   1. Zug 100 km/h von A → Entfernung zt = 100t
   2. Auto 80 km/h von B → Entfernung za = 80t
   3. Treffen: 100t + 80t = 200
   4. 180t = 200
   5. t = 1.11 Stunden

Sie treffen sich nach ~1 Stunde und 7 Minuten"

Ergebnis: RICHTIG!
Accuracy: 85% (17 von 20)
Tokens: 200 + 300 = 500 total
Cost: €0.008 (2× teurer Input, aber 85% vs 25%!)

[2-3 beispiele mit CoT gezeigt]
[Problem 5 mal generieren lassen, votieren]

Accuracy: 95% (19 von 20)
Tokens: (200 + 500) × 5 = 3500 total
Cost: €0.05 (12× teurer als ohne CoT)

# Extended Thinking aktivieren
response = client.messages.create(
    model="claude-3-7-sonnet",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # 10K Tokens zum Denken
    },
    messages=[{
        "role": "user",
        "content": "Komplexes mathematisches Problem..."
    }]
)

# Response hat 2 Parts:
# 1. Thinking (internal, nicht in Output sichtbar)
# 2. Text (die finale Antwort)

Problem: "Analysiere ob dieses Startup ein Product-Market Fit hat"

Normaler Prompt:
→ Oberflächliche Antwort

CoT Prompt:
1. Definiere Product-Market Fit (was bedeutet das genau?)
2. Analysiere Produkt: Was macht es? Wer sind Nutzer?
3. Analysiere Markt: Wie groß? Wächst er?
4. Analysiere Feedback: Churn? NPS? Usage?
5. Cross-reference: Entspricht 1-4 der Definition von 2?
6. Fazit: Ja/Nein mit Confidence-Level

# Meta-Prompt: Claude schreibt den CoT-Prompt
import anthropic

client = anthropic.Anthropic()

# Step 1: Lasse Claude einen CoT-Prompt generieren
template_prompt = f"""
Erstelle einen Chain-of-Thought Prompt für dieses Problem:
{problem_description}

Format:
"[Original Problem]
Lass mich denken:
1. [Step 1 description]
2. [Step 2 description]
..."
"""

template_response = client.messages.create(
    model="claude-3-opus-20240229",
    max_tokens=1000,
    messages=[{"role": "user", "content": template_prompt}]
)

cot_template = template_response.content[0].text

# Step 2: Nutze die generierte Template
final_prompt = cot_template.format(problem=actual_problem)
result = client.messages.create(
    model="claude-3-sonnet-20240229",
    max_tokens=2000,
    messages=[{"role": "user", "content": final_prompt}]
)

❌ FALSCH
Q: "Was ist die Hauptstadt von Frankreich?"
   Lass mich denken:
   1. Frankreich ist ein Land
   2. Länder haben Hauptstädte
   3. Die Hauptstadt von Frankreich ist...
A: "Paris"

❌ Waste: Extra 300 Tokens für Trivial-Answer!

✓ RICHTIG
Q: "Was ist die Hauptstadt von Frankreich?"
A: "Paris"

❌ FALSCH
Q: "Fasse diesen 10.000-Wort-Artikel zusammen"
   Lass mich denken:
   [Modell denkt 500 Tokens]
   [Gibt 2000-Wort-Summary statt <500 Wörter]

Result: Longer Summary, nicht kürzer!

✓ RICHTIG
Q: "Summarize in <100 words, keine CoT"
Result: Prägnant und kurz.

❌ Mobile App, User wartet auf Antwort
   Mit CoT: 5 Sekunden
   Mit CoT: 2 Sekunden + 100ms CoT-Overhead
   User: "App ist langsam!"

✓ Nutze schnellere Modelle (Haiku)
   statt CoT (wenn ≤1s Latency nötig)