Differenze tra i modelli di reasoning
Chain-of-thought interna e modelli standard: cosa cambia per chi scrive i prompt
Differenze tra i modelli di reasoning è una lezione AI Prompt Engineering gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Prompt Engineering, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Prompt Engineering include 4 lezioni in totale.
Che cosa sono i modelli di ragionamento
I modelli di ragionamento sono LLM addestrati e configurati specificamente per eseguire un'elaborazione interna prolungata prima di produrre una risposta. Tra gli esempi figurano la serie o1/o3/o4 di OpenAI e Claude di Anthropic con il ragionamento esteso abilitato.
A differenza dei modelli standard, che generano direttamente il testo token dopo token a partire dal prompt, i modelli di ragionamento producono prima una lunga catena di pensiero interna e poi la riassumono in una risposta finale.
Standard e di ragionamento: ciò che vede
Dal punto di vista dell'utente dell'API, la differenza è la seguente:
- Modello standard: Input → Output (veloce, diretto)
- Modello di ragionamento: Input → [elaborazione interna, nascosta o trasmessa in streaming] → Output (più lento, più accurato sui problemi complessi)
Il processo di elaborazione è l'area di lavoro privata del modello. Può contenere tentativi a vuoto, autocorrezioni e calcoli intermedi che non compaiono mai nella risposta finale.
Serie o di OpenAI: comportamento dell'API
I modelli o1/o3/o4 di OpenAI gestiscono internamente il ragionamento: per impostazione predefinita, i token del ragionamento non sono visibili. È possibile osservare il numero di token di ragionamento nei metadati di utilizzo, ma non il loro contenuto.
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)Ragionamento esteso di Claude: comportamento dell'API
Claude di Anthropic espone i token del ragionamento esteso tramite l'API. È possibile trasmettere in streaming e osservare il processo di ragionamento del modello in tempo reale. Il contenuto del ragionamento compare prima della risposta finale.
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)Trasmettere in streaming i token del ragionamento
È possibile trasmettere il ragionamento esteso in tempo reale, osservando lo svolgimento del ragionamento del modello. Questa funzione è utile per l'esperienza utente: può mostrare un'animazione di «elaborazione» o consentire agli utenti esperti di osservare il processo di ragionamento.
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.')Che cosa accade internamente: l'area di lavoro
Il ragionamento interno del modello è un'area di lavoro in cui può:
- Esplorare più approcci prima di sceglierne uno
- Eseguire calcoli e verificarli
- Individuare i propri errori e tornare sui propri passi
- Considerare i casi limite
- Pianificare soluzioni in più passaggi
Questa deliberazione interna spiega perché i modelli di ragionamento superano di gran lunga i modelli standard nei problemi complessi di matematica, programmazione e pianificazione strategica: in pratica, eseguono una revisione della letteratura prima di scrivere.
budget_tokens: Controllare la profondità del ragionamento
budget_tokens (Claude) o reasoning_effort (OpenAI) controlla quanto ragionamento svolge il modello. Più ragionamento significa maggiore accuratezza sui problemi difficili, ma anche costi e latenza più elevati.
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 e modelli di ragionamento
I modelli di ragionamento si comportano diversamente in base alle impostazioni della temperatura:
- Per gli o-series di OpenAI: la temperatura è impostata su 1 per impostazione predefinita e non sempre può essere modificata
- Per il ragionamento esteso di Claude: durante il ragionamento la temperatura è generalmente impostata su 1
Non cerchi di usare la temperatura per controllare il comportamento dei modelli di ragionamento: utilizzi invece budget_tokens o 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])Benchmark delle prestazioni: dove il ragionamento fa la differenza
I modelli di ragionamento superano più nettamente i modelli standard nei seguenti ambiti:
- Matematica competitiva: AIME, AMC (o3 è quasi al livello di un esperto umano)
- Programmazione complessa: programmazione competitiva (Codeforces)
- Ragionamento scientifico: GPQA (scienze di livello universitario avanzato)
- Logica a più passaggi: problemi che richiedono deduzioni sequenziali
Per le attività semplici, come grammatica, riepiloghi e domande e risposte fattuali, i modelli standard offrono prestazioni altrettanto buone a un costo 10-100 volte inferiore.
La realtà della latenza
I modelli di ragionamento sono lenti. Un problema difficile con un elevato livello di ragionamento può richiedere 30-60 secondi. Pianifichi di conseguenza l'esperienza utente:
- Mostri indicatori di avanzamento come 'ragionamento in corso...'
- Utilizzi lo streaming per mostrare i risultati parziali non appena sono disponibili
- Non utilizzi modelli di ragionamento per le chat in tempo reale, quando la latenza è importante
- Precalcoli gli output dei modelli di ragionamento per le domande difficili note
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
)Modelli di ragionamento e prompt di sistema
I modelli di ragionamento rispondono ai prompt di sistema in modo diverso rispetto ai modelli standard. Poiché riflettono internamente prima di rispondere, possono seguire con maggiore affidabilità istruzioni complesse e articolate in più passaggi nei prompt di sistema.
Tuttavia, prompt di sistema molto lunghi e vincolanti possono entrare in conflitto con il ragionamento interno. Buona pratica: mantenga concisi i prompt di sistema per i modelli di ragionamento; definisca il ruolo e il formato dell'output, quindi lasci che il ragionamento interno del modello gestisca la strategia.
Verifica delle conoscenze: il ragionamento dei modelli di ragionamento
Qual è la differenza fondamentale tra ciò che fornisce l'autore del prompt e ciò che avviene internamente in un modello di ragionamento?
Riepilogo: in che modo differiscono i modelli di ragionamento
I modelli di ragionamento come o1/o3 e Claude con ragionamento esteso eseguono una catena di pensiero interna prima di rispondere. L'autore del prompt fornisce un problema; il modello riflette internamente, esplora diversi approcci e si autocorregge, quindi produce una risposta finale. Lei controlla la profondità del ragionamento con budget_tokens (Claude) o reasoning_effort (OpenAI). I modelli di ragionamento eccellono nella matematica complessa, nella programmazione e nella logica a più passaggi, ma sono 10-100 volte più costosi e 10-100 volte più lenti dei modelli standard. Utilizzi lo streaming e gli indicatori di avanzamento per gestire la latenza nella sua esperienza utente.
Domande Frequenti
La lezione «Differenze tra i modelli di reasoning» è gratuita?
Sì — il testo completo di «Differenze tra i modelli di reasoning» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Prompt Engineering, passa a CoddyKit PRO. Il corso AI Prompt Engineering include 4 lezioni in totale.
Cosa imparerò in «Differenze tra i modelli di reasoning»?
Chain-of-thought interna e modelli standard: cosa cambia per chi scrive i prompt Eserciti AI Prompt Engineering con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare AI Prompt Engineering?
Non è richiesta alcuna esperienza precedente. AI Prompt Engineering su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Differenze tra i modelli di reasoning»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione AI Prompt Engineering?
Sì. Ogni lezione AI Prompt Engineering include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Differenze tra i modelli di reasoning
- Prompt efficaci per il ragionamento esteso
- Quando usare modelli di reasoning o standard
- Compromessi tra costi e latenza