Czym różnią się modele rozumujące
Wewnętrzny chain-of-thought a standardowe modele: co zmienia się dla autora promptów.
Czym różnią się modele rozumujące to bezpłatna lekcja AI Prompt Engineering na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Prompt Engineering, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.
Czym są modele rozumujące
Modele rozumujące to modele LLM specjalnie trenowane i skonfigurowane tak, aby przed udzieleniem odpowiedzi prowadziły wydłużone wewnętrzne rozumowanie. Przykłady obejmują serie o1/o3/o4 firmy OpenAI oraz model Claude firmy Anthropic z włączonym rozszerzonym rozumowaniem.
W przeciwieństwie do standardowych modeli, które generują tekst bezpośrednio z promptu, token po tokenie, modele rozumujące najpierw tworzą obszerny wewnętrzny łańcuch myśli, a następnie podsumowują go w końcowej odpowiedzi.
Standardowy a rozumujący: co widać
Z perspektywy użytkownika API różnica wygląda następująco:
- Model standardowy: dane wejściowe → wynik (szybko i bezpośrednio)
- Model rozumujący: dane wejściowe → [wewnętrzne rozumowanie, ukryte lub przesyłane strumieniowo] → wynik (wolniej, ale większa dokładność w przypadku trudnych problemów)
Proces rozumowania jest prywatnym brudnopisem modelu. Może zawierać błędne ścieżki, samokorekty i obliczenia pośrednie, które nigdy nie pojawiają się w końcowej odpowiedzi.
Serie o OpenAI: zachowanie API
Modele o1/o3/o4 firmy OpenAI przeprowadzają rozumowanie wewnętrznie — domyślnie nie widać tokenów rozumowania. Liczbę tokenów rozumowania można sprawdzić w metadanych użycia, ale nie ich treść.
import openai
client = openai.OpenAI(api_key='sk-...')
# o3 — reasoning happens internally
response = client.chat.completions.create(
model='o3',
messages=[
{'role': 'user', 'content': 'Solve: A train leaves Chicago at 9am going 60mph. Another leaves NYC at 10am going 80mph. If the distance is 790 miles, when do they meet?'}
],
# reasoning_effort='high' # Optional: 'low', 'medium', 'high'
)
print(response.choices[0].message.content)
# Check how many tokens were used for thinking:
print('Input tokens:', response.usage.prompt_tokens)
print('Output tokens:', response.usage.completion_tokens)Rozszerzone rozumowanie Claude: zachowanie API
Claude firmy Anthropic udostępnia tokeny rozszerzonego rozumowania za pośrednictwem API. Można przesyłać strumieniowo i obserwować proces rozumowania modelu w czasie rzeczywistym. Treść rozumowania pojawia się przed końcową odpowiedzią.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
# Enable extended thinking
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=16000,
thinking={
'type': 'enabled',
'budget_tokens': 10000 # Max tokens for thinking
},
messages=[{
'role': 'user',
'content': 'What is the 100th prime number?'
}]
)
# Response contains both thinking blocks and text blocks
for block in response.content:
if block.type == 'thinking':
print('THINKING:', block.thinking[:200], '...')
elif block.type == 'text':
print('ANSWER:', block.text)Przesyłanie strumieniowe tokenów rozumowania
Można przesyłać strumieniowo rozszerzone rozumowanie w czasie rzeczywistym i obserwować, jak przebiega rozumowanie modelu. Jest to przydatne z punktu widzenia UX — można wyświetlać animację „myślenia” lub pozwolić zaawansowanym użytkownikom obserwować proces rozumowania.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
def stream_with_thinking(question):
with client.messages.stream(
model='claude-opus-4-5',
max_tokens=16000,
thinking={'type': 'enabled', 'budget_tokens': 8000},
messages=[{'role': 'user', 'content': question}]
) as stream:
current_block_type = None
for event in stream:
# Track which block type we're in
if hasattr(event, 'type'):
if 'thinking' in str(event.type):
current_block_type = 'thinking'
elif 'text' in str(event.type):
current_block_type = 'text'
# Print text delta
if hasattr(event, 'delta') and hasattr(event.delta, 'text'):
prefix = '[THINK] ' if current_block_type == 'thinking' else '[ANS] '
print(prefix + event.delta.text, end='', flush=True)
stream_with_thinking('Explain why P != NP is unproven.')Co dzieje się wewnętrznie: brudnopis
Wewnętrzne rozumowanie modelu jest brudnopisem, w którym może on:
- rozważać wiele podejść przed dokonaniem wyboru
- wykonywać obliczenia i je weryfikować
- rozpoznawać własne błędy i wracać do wcześniejszych etapów
- uwzględniać przypadki brzegowe
- planować rozwiązania wieloetapowe
To wewnętrzne rozumowanie wyjaśnia, dlaczego modele rozumujące znacznie przewyższają standardowe modele w trudnych zadaniach matematycznych, programistycznych i planowaniu strategicznym — w zasadzie wykonują przegląd literatury przed napisaniem odpowiedzi.
budget_tokens: Kontrolowanie głębokości rozumowania
budget_tokens (Claude) lub reasoning_effort (OpenAI) określa, ile rozumowania wykonuje model. Więcej rozumowania oznacza większą dokładność w przypadku trudnych problemów, ale także wyższy koszt i większe opóźnienie.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
def ask_with_budget(question, budget):
r = client.messages.create(
model='claude-opus-4-5',
max_tokens=budget + 2048, # must exceed budget_tokens
thinking={'type': 'enabled', 'budget_tokens': budget},
messages=[{'role': 'user', 'content': question}]
)
thinking_tokens = sum(
len(b.thinking.split()) * 1.3 # rough estimate
for b in r.content if b.type == 'thinking'
)
answer = next(b.text for b in r.content if b.type == 'text')
return answer, int(thinking_tokens)
# Same hard question with different budgets
q = 'Prove that the square root of 2 is irrational.'
ans_small, tok_small = ask_with_budget(q, 1024)
ans_large, tok_large = ask_with_budget(q, 8000)
print(f'Small budget ({tok_small} thinking tokens): {ans_small[:100]}')
print(f'Large budget ({tok_large} thinking tokens): {ans_large[:100]}')Temperatura a modele rozumujące
Modele rozumujące działają inaczej w zależności od ustawień temperatury:
- W przypadku modeli OpenAI z serii o temperatura domyślnie wynosi 1 i nie zawsze można jej zmienić
- W przypadku rozszerzonego rozumowania Claude temperatura jest zazwyczaj ustawiona na 1 podczas rozumowania
Nie należy używać temperatury do kontrolowania działania modeli rozumujących — zamiast tego należy użyć budget_tokens lub reasoning_effort.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
# For Claude with extended thinking, temperature=1 is the default
# and best practice
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=10000,
temperature=1, # Required to be 1 when extended thinking is enabled
thinking={
'type': 'enabled',
'budget_tokens': 5000
},
messages=[{
'role': 'user',
'content': 'Write a Python function to find all prime numbers up to N.'
}]
)
print(response.content[-1].text[:300])Testy wydajności: gdzie modele rozumujące wygrywają
Modele rozumujące mają największą przewagę nad standardowymi modelami w następujących obszarach:
- Matematyka konkursowa: AIME, AMC (o3 osiąga poziom zbliżony do ludzkiego eksperta)
- Złożone programowanie: programowanie konkursowe (Codeforces)
- Rozumowanie naukowe: GPQA (nauka na poziomie studiów magisterskich)
- Logika wieloetapowa: problemy wymagające wnioskowania sekwencyjnego
W przypadku prostych zadań (gramatyka, podsumowywanie, pytania i odpowiedzi oparte na faktach) standardowe modele radzą sobie równie dobrze, a ich koszt jest od 10 do 100 razy niższy.
Rzeczywistość opóźnień
Modele rozumujące działają wolno. Rozwiązanie trudnego problemu przy wysokim poziomie rozumowania może zająć od 30 do 60 sekund. Należy odpowiednio zaplanować interfejs użytkownika:
- Należy wyświetlać wskaźniki postępu z komunikatem „rozumowanie…”
- Należy używać strumieniowania, aby wyświetlać dostępne częściowe wyniki
- Nie należy używać modeli rozumujących w czatach czasu rzeczywistego, w których opóźnienie ma znaczenie
- Dla znanych trudnych pytań należy wcześniej obliczać wyniki modeli rozumujących
import time
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
def timed_reasoning_call(question, budget):
start = time.time()
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=budget + 2000,
thinking={'type': 'enabled', 'budget_tokens': budget},
messages=[{'role': 'user', 'content': question}]
)
elapsed = time.time() - start
answer = next(b.text for b in response.content if b.type == 'text')
print(f'Latency: {elapsed:.1f}s | Answer: {answer[:100]}')
return answer
# Hard problem — expect 20-45 seconds
timed_reasoning_call(
'Design a database schema for a multi-tenant SaaS billing system.',
budget=8000
)Modele rozumujące a prompty systemowe
Modele rozumujące reagują na prompty systemowe inaczej niż standardowe modele. Ponieważ wewnętrznie analizują problem przed udzieleniem odpowiedzi, mogą bardziej niezawodnie wykonywać złożone, wieloetapowe instrukcje zawarte w promptach systemowych.
Jednak bardzo długie i ograniczające prompty systemowe mogą kolidować z wewnętrznym rozumowaniem. Najlepsza praktyka: w przypadku modeli rozumujących należy tworzyć zwięzłe prompty systemowe — zdefiniować rolę i format wyniku, a następnie pozwolić, aby wewnętrzne rozumowanie modelu zajęło się strategią.
Sprawdzenie wiedzy: rozumowanie modelu
Jaka jest kluczowa różnica między tym, co dostarcza autor promptu, a tym, co zachodzi wewnętrznie w modelu rozumującym?
Podsumowanie: czym różnią się modele rozumujące
Modele rozumujące, takie jak o1/o3 oraz Claude z rozszerzonym rozumowaniem, przed udzieleniem odpowiedzi wykonują wewnętrzny łańcuch rozumowania. Autor promptu przedstawia problem, a model wewnętrznie go analizuje, bada różne podejścia i koryguje własne błędy, po czym generuje ostateczną odpowiedź. Głębokość rozumowania można kontrolować za pomocą budget_tokens (Claude) lub reasoning_effort (OpenAI). Modele rozumujące doskonale radzą sobie ze złożoną matematyką, programowaniem i logiką wieloetapową, ale są od 10 do 100 razy droższe i od 10 do 100 razy wolniejsze od standardowych modeli. Aby zarządzać opóźnieniami w interfejsie użytkownika, należy używać strumieniowania i wskaźników postępu.
Często zadawane pytania
Czy lekcja „Czym różnią się modele rozumujące” jest bezpłatna?
Tak — pełny tekst „Czym różnią się modele rozumujące” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Prompt Engineering, przejdź na CoddyKit PRO. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.
Co nauczysz się w „Czym różnią się modele rozumujące”?
Wewnętrzny chain-of-thought a standardowe modele: co zmienia się dla autora promptów. Ćwiczysz AI Prompt Engineering z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć AI Prompt Engineering?
Nie wymagamy żadnego doświadczenia. AI Prompt Engineering w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.
Ile czasu zajmuje lekcja „Czym różnią się modele rozumujące”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji AI Prompt Engineering?
Tak. Każda lekcja AI Prompt Engineering zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Czym różnią się modele rozumujące
- Skuteczne prompty dla extended thinking
- Kiedy używać modeli rozumujących, a kiedy standardowych
- Kompromisy między kosztem a opóźnieniem