Quando il fine-tuning supera il prompting
Individui i casi d'uso in cui il fine-tuning è più vantaggioso del prompt engineering: aderenza costante allo stile, conoscenza proprietaria del dominio, riduzione dei costi dei token grazie a prompt più brevi e miglioramenti della latenza.
Quando il fine-tuning supera il prompting è una lezione AI Engineering Academy 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 Engineering Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Engineering Academy include 4 lezioni in totale.
Il compromesso fondamentale
Quando è necessario che un LLM si comporti in un modo specifico, si hanno due opzioni fondamentali: il prompt engineering (indicare al modello cosa fare al momento dell’inferenza usando prompt elaborati con cura) oppure il fine-tuning (insegnare al modello nuovi comportamenti addestrandolo su esempi). Entrambi possono produrre risultati simili per molte attività, ma differiscono notevolmente in termini di costi, velocità, flessibilità e livello qualitativo massimo raggiungibile.
Quando è preferibile il prompting
Il prompting è quasi sempre il punto di partenza giusto. Non richiede un’infrastruttura di addestramento, produce risultati nel giro di poche ore, può essere aggiornato immediatamente senza ripetere l’addestramento e funziona bene per le attività che il modello di base sa già gestire in modo adeguato. Inizi con il prompting per: attività in cui GPT-4o o Claude produce già risultati accettabili con istruzioni chiare, requisiti che cambiano rapidamente, casi d’uso a basso volume e situazioni in cui si sta ancora esplorando il problema.
# Prompting is sufficient for most well-defined tasks
system_prompt = '''
You are a customer support agent for TechCorp. Your tone is friendly but professional.
Always:
1. Acknowledge the customer's issue in the first sentence
2. Provide step-by-step solutions with numbered lists
3. End with 'Is there anything else I can help you with?'
Never: reveal pricing, discuss competitors, or make promises about future features.
'''
# With clear instructions, GPT-4o handles this well - no fine-tuning needed
# Before investing in fine-tuning, prove prompting is insufficientStile coerente e rispetto del formato
Il fine-tuning è la scelta migliore quando è necessario un formato di output rigorosamente coerente che il prompting non riesce a garantire in modo affidabile. Se l’applicazione richiede il rispetto al 100% di uno specifico schema JSON, di un formato documentale strutturato con precisione o di uno stile di scrittura molto particolare, diverso dall’output naturale del modello, un fine-tuning con qualche centinaio di esempi può raggiungere una coerenza quasi perfetta, che nemmeno il prompt progettato con la massima cura riesce a garantire.
# Problem: prompting gives 90% format compliance - 10% failures cause downstream errors
# Prompt approach (unreliable)
system = 'Always respond with JSON: {"category": "...", "priority": 1-5, "tags": [...]}'
# 1 in 10 responses adds explanation text, omits a field, or uses strings for priority
# Fine-tuned approach: train on 500 examples of perfect output
# Training example format:
train_example = {
'messages': [
{'role': 'system', 'content': 'Classify customer support tickets.'},
{'role': 'user', 'content': 'My order is late and I need it for tomorrow.'},
{'role': 'assistant', 'content': '{"category": "shipping", "priority": 4, "tags": ["late_delivery", "urgent"]}'}
]
}
# After fine-tuning: 99.5%+ format compliance with minimal system promptConoscenze proprietarie del dominio
Il fine-tuning è la scelta giusta quando il modello deve apprendere conoscenze che non esistono nei dati di addestramento pubblici: le convenzioni interne di programmazione della sua azienda, una tassonomia proprietaria per classificare i documenti, una terminologia legale o medica specializzata in un settore di nicchia oppure le linee guida specifiche sul tono e sullo stile del suo brand. Queste conoscenze non possono essere trasmesse efficacemente tramite esempi nel prompt, perché il volume degli esempi supera ciò che può essere contenuto in una finestra di contesto.
# Example: Internal code style with dozens of company-specific conventions
# Too many rules to fit in a prompt effectively:
# Company conventions (partial list of 200+):
# - Use AppException instead of RuntimeError
# - Repositories are named FooRepository not FooRepo
# - Service methods use handle_verb_noun naming not do_action
# - Config values go through AppConfig.get(), never os.environ directly
# - ... 196 more conventions
# Prompting: you can include ~20 conventions before the model starts ignoring them
# Fine-tuning: train on 1000 examples of compliant vs. non-compliant code
# Result: model learns ALL conventions and applies them automaticallyRiduzione dei costi dei token tramite prompt più brevi
Un importante argomento economico a favore del fine-tuning è la compressione del prompt. Un prompt di sistema complesso può contenere 2000 token. Se si chiama l’API 10 milioni di volte al giorno, quei 2000 token costano decine di migliaia di dollari al mese. Un modello sottoposto a fine-tuning può essere guidato da un prompt molto più breve (50-100 token), perché le istruzioni dettagliate sono ormai incorporate nei pesi. Su larga scala, questo può ridurre i costi dei token di input del 90% o più.
COST_PER_1K_TOKENS_INPUT = 0.0050 # gpt-4o
DAILY_REQUESTS = 10_000_000
# Base model with detailed prompt
base_prompt_tokens = 2000
daily_input_tokens_base = DAILY_REQUESTS * base_prompt_tokens
daily_cost_base = (daily_input_tokens_base / 1000) * COST_PER_1K_TOKENS_INPUT
# Fine-tuned model with short prompt
fine_tuned_prompt_tokens = 50
daily_input_tokens_ft = DAILY_REQUESTS * fine_tuned_prompt_tokens
daily_cost_ft = (daily_input_tokens_ft / 1000) * COST_PER_1K_TOKENS_INPUT
print(f'Base model daily input cost: ${daily_cost_base:,.2f}')
print(f'Fine-tuned model daily input cost: ${daily_cost_ft:,.2f}')
print(f'Monthly savings: ${(daily_cost_base - daily_cost_ft) * 30:,.2f}')
# Base: $100,000/day. Fine-tuned: $2,500/day. Savings: ~$2.9M/monthRiduzione della latenza
I modelli sottoposti a fine-tuning possono migliorare la latenza in due modi. Innanzitutto, prompt più brevi significano che il modello elabora meno token di input, riducendo direttamente il tempo necessario per generare il primo token. Inoltre, i modelli sottoposti a fine-tuning spesso convergono più rapidamente verso il formato corretto (generano meno token nella risposta prima di arrivare alla risposta effettiva), riducendo il numero totale di token di output e il tempo di generazione. Per le applicazioni sensibili alla latenza, entrambi gli effetti si sommano e producono miglioramenti significativi.
# Latency comparison (approximate)
# Base model with 2000-token prompt:
# - Input tokens processed: 2000 + 50 (user query) = 2050
# - Response: often starts with 'Sure! Here is...' (5-10 unnecessary tokens)
# - TTFT: ~800ms (more tokens to process)
# Fine-tuned model with 50-token prompt:
# - Input tokens processed: 50 + 50 (user query) = 100
# - Response: starts directly with the answer (no preamble)
# - TTFT: ~100ms (few tokens to process)
# For classification tasks (short outputs), this is a 5-8x latency improvement
# For generation tasks, improvement is less dramatic but still significant
print('Fine-tuning trades upfront training cost for per-request latency+cost savings')Il requisito minimo di dati
Il fine-tuning richiede dati di addestramento e questo rappresenta spesso il principale ostacolo pratico. Come regola generale: servono almeno 50-100 esempi di alta qualità per osservare un miglioramento significativo rispetto al modello di base, 500-1000 esempi per ottenere un rispetto affidabile dello stile e del formato e 1000-10.000 esempi per acquisire una quantità significativa di conoscenze di dominio. Al di sotto dei 50 esempi, il prompting con gli stessi esempi nel contesto (few-shot) offrirà solitamente prestazioni migliori del fine-tuning.
def estimate_fine_tuning_feasibility(num_examples: int, task_type: str) -> str:
if num_examples < 50:
return 'Insufficient data. Use few-shot prompting with these examples instead.'
if task_type == 'format_adherence' and num_examples >= 100:
return 'Fine-tuning recommended. Format consistency issues are hard to solve with prompting.'
if task_type == 'style_matching' and num_examples >= 300:
return 'Fine-tuning recommended. Consistent style requires enough examples to learn the distribution.'
if task_type == 'domain_knowledge' and num_examples >= 500:
return 'Fine-tuning recommended if knowledge is truly proprietary.'
return 'Continue with advanced prompting (chain-of-thought, structured output) and revisit fine-tuning when you have more data.'I costi nascosti del fine-tuning
Il fine-tuning comporta costi nascosti significativi oltre a quelli di calcolo. Servono: un’infrastruttura per eseguire l’addestramento (ore GPU o un servizio gestito), un processo per raccogliere i dati e controllarne la qualità, una valutazione per verificare che il modello sottoposto a fine-tuning migliori effettivamente la metrica obiettivo, una pipeline di deployment per il modello personalizzato e un processo di manutenzione continua per ripetere l’addestramento quando il modello di base viene aggiornato o cambiano i requisiti. Questi costi sono reali e devono essere valutati rispetto ai vantaggi.
fine_tuning_total_cost = {
'data_collection_and_QA': '$5,000-$50,000', # human annotation or LLM-generated
'training_compute': '$50-$5,000', # depends on model size and data volume
'evaluation_pipeline': '$500-$2,000', # building eval harness
'deployment_infra': '$200-$2,000/month', # serving the custom model
'maintenance': '$1,000-$5,000/year', # retraining when things change
'opportunity_cost': 'weeks to months', # time to build vs. prompt iteration
}
# Compare to prompting costs:
prompting_costs = {
'data_needed': None, # no training data required
'infra': '$0 (uses existing API)',
'maintenance': 'update prompts when needed',
'time_to_production': 'hours to days'
}Aggiornamento delle conoscenze: RAG o fine-tuning
Il fine-tuning non può aggiornare le conoscenze in tempo reale. Le conoscenze di un modello sottoposto a fine-tuning restano congelate al momento dell’addestramento. Per i casi d’uso che richiedono informazioni aggiornate (eventi attuali, prezzi in tempo reale, normative soggette a cambiamenti), il RAG è sempre la scelta migliore, perché può recuperare informazioni aggiornate al momento della richiesta. Il fine-tuning è invece ideale per le conoscenze durature che cambiano raramente: lo stile di scrittura dell’azienda, la tassonomia per categorizzare i prodotti o il vocabolario tecnico di un settore consolidato.
# Decision guide: RAG vs Fine-tuning vs Prompting
def choose_approach(requirements: dict) -> str:
if requirements.get('knowledge_changes_frequently'): # pricing, news, live data
return 'RAG - knowledge must be updatable at query time'
if requirements.get('needs_consistent_format') and requirements.get('high_volume'):
return 'Fine-tuning - format adherence + cost savings at scale'
if requirements.get('proprietary_domain_vocabulary'):
return 'Fine-tuning - model needs to learn new terminology'
if requirements.get('low_volume') or requirements.get('still_exploring'):
return 'Prompting - fastest iteration, lowest cost'
if requirements.get('combination_needed'): # most production systems
return 'Fine-tuning for style/format + RAG for dynamic knowledge'Il framework ideale per decidere se usare il fine-tuning
Utilizzi questo framework decisionale prima di impegnarsi nel fine-tuning. Innanzitutto, dimostri che è necessario: esegua il prompt migliore su 1000 esempi reali e misuri il tasso di errore. In secondo luogo, quantifichi il vantaggio: stimi il ROI derivante da una maggiore accuratezza, da costi inferiori dei token o da una latenza migliore. Terzo, valuti la fattibilità: dispone di oltre 500 esempi di addestramento di alta qualità? Infine, confronti le alternative: un modello più piccolo con un prompt migliore potrebbe raggiungere le prestazioni di un modello più grande con un prompt complesso?
Combinare prompting e fine-tuning
I migliori sistemi di produzione spesso combinano entrambi gli approcci. Usi il fine-tuning per le proprietà durature (formato dell’output, tono, vocabolario di dominio) che cambiano raramente e i prompt per le proprietà dinamiche (contesto dell’attività, documenti recuperati, preferenze dell’utente) che cambiano a ogni richiesta. Questa combinazione offre l’affidabilità e l’efficienza dei costi del fine-tuning senza sacrificare la flessibilità del prompting.
Verifica rapida
Verifichi la sua comprensione di quando il fine-tuning è preferibile al prompting sulla base di questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che il prompting è quasi sempre il punto di partenza giusto grazie ai costi inferiori e alla maggiore rapidità di iterazione, che il fine-tuning è la scelta migliore per il rispetto coerente del formato, le conoscenze proprietarie del dominio e la riduzione dei costi dei token in caso di volumi elevati e che l’aggiornamento delle conoscenze è l’ambito del RAG: il fine-tuning non può aggiornare ciò che un modello conosce durante l’esecuzione. Nella prossima lezione prepareremo un dataset di addestramento di alta qualità per il fine-tuning.
Impara Python con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 30
- Lezioni
- 120
Domande Frequenti
La lezione «Quando il fine-tuning supera il prompting» è gratuita?
Sì — il testo completo di «Quando il fine-tuning supera il prompting» è 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 Engineering Academy, passa a CoddyKit PRO. Il corso AI Engineering Academy include 4 lezioni in totale.
Cosa imparerò in «Quando il fine-tuning supera il prompting»?
Individui i casi d'uso in cui il fine-tuning è più vantaggioso del prompt engineering: aderenza costante allo stile, conoscenza proprietaria del dominio, riduzione dei costi dei token grazie a prompt… Eserciti AI Engineering Academy 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 Engineering Academy?
Non è richiesta alcuna esperienza precedente. AI Engineering Academy 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 «Quando il fine-tuning supera il prompting»?
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 Engineering Academy?
Sì. Ogni lezione AI Engineering Academy 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
- Quando il fine-tuning supera il prompting
- Preparare un dataset di addestramento di alta qualità
- Fine-tuning LoRA con Hugging Face PEFT
- Valutare e distribuire il modello sottoposto a fine-tuning