Chain-of-Thought prompting je revoluční technika, která umožňuje jazykovým modelům řešit složité úlohy postupně, krok za krokem. Tato metoda dramaticky zlepšuje schopnost AI systémů v logickém uvažování a řešení problémů.
Chain-of-Thought Prompting: Revoluce v logickém uvažování AI¶
Chain-of-Thought (CoT) prompting představuje průlomový přístup k práci s velkými jazykovými modely, který dramaticky zlepšuje jejich schopnost řešit složité úlohy vyžadující logické uvažování. Místo jednoduchého dotazu a odpovědi nutí model explicite ukázat své “myšlení” krok za krokem.
Základní principy Chain-of-Thought¶
Tradiční přístup k promptingu funguje na principu input → output. CoT zavádí mezikrok reasoning, čímž transformuje proces na input → reasoning → output. Model tak musí svůj myšlenkový proces verbalizovat, což vede k lepším výsledkům zejména u matematických úloh, logických problémů a komplexního rozhodování.
Klíčové výhody CoT promptingu:
- Zlepšená přesnost - model dělá méně chyb při složitých úlohách
- Transparentnost - vidíme, jak model k odpovědi dospěl
- Debugovatelnost - můžeme identifikovat, kde se reasoning pokazil
- Konzistence - model produkuje stabilnější výsledky
Implementace Few-Shot CoT¶
Nejjednodušší způsob implementace CoT je pomocí few-shot learning s demonstračními příklady. Ukážeme modelu, jak má “přemýšlet” na konkrétních případech:
def create_cot_prompt(question):
examples = """
Otázka: V obchodě bylo 23 jablek. Prodali 16 jablek a pak přivezli dalších 45. Kolik jablek je teď v obchodě?
Uvažování:
1. Na začátku: 23 jablek
2. Po prodeji: 23 - 16 = 7 jablek
3. Po dodávce: 7 + 45 = 52 jablek
Odpověď: 52 jablek
---
Otázka: Tomáš má o 3 roky více než Pavel. Součet jejich věků je 27. Kolik let má Pavel?
Uvažování:
1. Označme Pavlův věk jako x
2. Tomášův věk je x + 3
3. Součet: x + (x + 3) = 27
4. Zjednodušení: 2x + 3 = 27
5. Řešení: 2x = 24, tedy x = 12
Odpověď: Pavel má 12 let
---
Otázka: {question}
Uvažování:"""
return examples.format(question=question)
Zero-Shot CoT s magickou frází¶
Překvapivě efektivní technikou je zero-shot CoT, kdy jednoduše přidáme frázi “Přemýšlej krok za krokem” nebo “Let’s think step by step”. Tato jednoduchá instrukce často stačí k aktivaci reasoning módu:
def zero_shot_cot(question):
prompt = f"""
{question}
Přemýšlej krok za krokem a ukaž své uvažování.
"""
return prompt
# Použití
question = "Firma má 150 zaměstnanců. 60% pracuje v IT, z nich 25% jsou senioři. Kolik seniorních IT pracovníků firma má?"
cot_prompt = zero_shot_cot(question)
Programové implementace CoT¶
Pro produkční nasazení můžeme CoT integrovat do našich aplikací pomocí strukturovaného přístupu:
class CoTReasoner:
def __init__(self, llm_client):
self.llm = llm_client
def solve_with_reasoning(self, problem, domain="general"):
system_prompt = self._get_system_prompt(domain)
user_prompt = self._format_problem(problem)
response = self.llm.chat([
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
])
return self._parse_response(response)
def _get_system_prompt(self, domain):
prompts = {
"math": "Jsi expert na matematiku. Vždy ukaž detailní postup řešení krok za krokem.",
"logic": "Analyzuj logické problémy systematicky. Rozlož složité úlohy na menší části.",
"general": "Při řešení složitých úloh vždy ukaž své uvažování krok za krokem."
}
return prompts.get(domain, prompts["general"])
def _format_problem(self, problem):
return f"""
{problem}
Postupuj následovně:
1. Identifikuj klíčové informace
2. Rozhodni, jaké kroky jsou potřebné
3. Proveď výpočty/analýzu krok za krokem
4. Ověř výsledek
5. Formuluj finální odpověď
Uvažování:
"""
def _parse_response(self, response):
# Parsování odpovědi pro extrakci reasoning a finální odpovědi
lines = response.split('\n')
reasoning = []
final_answer = None
in_reasoning = False
for line in lines:
if 'Uvažování:' in line or 'Reasoning:' in line:
in_reasoning = True
continue
elif 'Odpověď:' in line or 'Answer:' in line:
final_answer = line.split(':', 1)[1].strip()
break
elif in_reasoning:
reasoning.append(line.strip())
return {
"reasoning_steps": [r for r in reasoning if r],
"final_answer": final_answer,
"full_response": response
}
Pokročilé techniky CoT¶
Pro ještě lepší výsledky můžeme použít pokročilé varianty CoT:
Self-Consistency CoT¶
Necháme model vyřešit úlohu několikrát různými způsoby a vybereme nejčastější odpověď:
def self_consistency_cot(problem, num_iterations=5):
answers = []
for i in range(num_iterations):
prompt = f"""
{problem}
Řeš tento problém krok za krokem. Použij jiný přístup než obvykle.
Uvažování:
"""
response = llm_client.generate(prompt)
parsed = parse_final_answer(response)
if parsed:
answers.append(parsed)
# Najdi nejčastější odpověď
from collections import Counter
most_common = Counter(answers).most_common(1)
return {
"consensus_answer": most_common[0][0] if most_common else None,
"confidence": most_common[0][1] / len(answers) if most_common else 0,
"all_answers": answers
}
Tree of Thoughts¶
Rozšíření CoT, kde model zkoumá více možných cest řešení současně:
def tree_of_thoughts(problem, depth=3, branches=3):
def explore_branch(current_thought, remaining_depth):
if remaining_depth == 0:
return [current_thought]
# Generuj možné další kroky
prompt = f"""
Dosavadní uvažování: {current_thought}
Navrhni {branches} různé způsoby, jak pokračovat v řešení:
1.
2.
3.
"""
response = llm_client.generate(prompt)
next_steps = parse_numbered_list(response)
all_paths = []
for step in next_steps:
new_thought = current_thought + " → " + step
paths = explore_branch(new_thought, remaining_depth - 1)
all_paths.extend(paths)
return all_paths
initial_thought = f"Problém: {problem}"
all_solution_paths = explore_branch(initial_thought, depth)
# Evaluuj každou cestu a vyber nejlepší
best_path = evaluate_paths(all_solution_paths)
return best_path
Praktické tipy pro nasazení¶
Při implementaci CoT v reálných aplikacích dodržujte tyto osvědčené postupy:
- Specifické instrukce - Definujte přesně, jaký typ reasoning očekáváte
- Strukturované výstupy - Použijte templaty pro konzistentní formátování
- Validace kroků - Implementujte kontroly logické konzistence
- Fallback strategie - Přepněte na jednodušší prompt, pokud CoT selže
- Monitoring - Sledujte kvalitu reasoning v produkci
def production_cot_wrapper(problem, max_retries=2):
for attempt in range(max_retries + 1):
try:
if attempt == 0:
# Zkus plný CoT
result = complex_cot_reasoning(problem)
elif attempt == 1:
# Zkus jednodušší CoT
result = simple_cot_reasoning(problem)
else:
# Fallback na základní prompt
result = basic_reasoning(problem)
# Validace výsledku
if validate_reasoning_quality(result):
return result
except Exception as e:
log_reasoning_error(e, attempt, problem)
continue
return {"error": "Nepodařilo se najít validní řešení", "attempts": max_retries + 1}
Shrnutí¶
Chain-of-Thought prompting představuje zásadní pokrok v práci s LLM, který výrazně zlepšuje kvalitu odpovědí u složitých úloh. Kombinace few-shot příkladů, strukturovaných promptů a pokročilých technik jako self-consistency umožňuje dosáhnout téměř lidské úrovně reasoning. Pro produkční nasazení je klíčové implementovat robustní validaci, monitoring a fallback strategie. CoT se tak stává nepostradatelnou součástí moderního AI toolkitu pro aplikace vyžadující logické uvažování.