Introduzione
Il panorama del fine-tuning degli LLM nel 2026 è simultaneamente più capace e più frammentato che mai. Due anni fa, fine-tuning significava LoRA su una singola GPU con una configurazione YAML e una preghiera. Oggi, i team scelgono tra almeno cinque framework seri, ciascuno con filosofie di design distinte, caratteristiche di performance e integrazioni ecosistemiche diverse. La scelta del framework ha conseguenze reali sulla velocità di addestramento, l'efficienza della memoria, la qualità del modello e la complessità operativa della pipeline di addestramento.
Questa guida fornisce un confronto approfondito e orientato alla pratica dei quattro framework di fine-tuning più ampiamente adottati: Axolotl, Unsloth, TorchTune e TRL (Transformer Reinforcement Learning). Copriamo anche LLaMA-Factory, che ha stabilito una posizione forte nella comunità ML asiatica e merita considerazione. Ogni framework si è ritagliato una nicchia, e comprendere queste nicchie è essenziale per fare una scelta informata.
Il confronto si basa su esecuzioni di addestramento reali attraverso multiple architetture di modelli, configurazioni GPU e metodi di addestramento. Ogni benchmark e esempio di configurazione in questa guida è stato validato su hardware e versioni software attuali a inizio 2026.
Lo Stato del Fine-Tuning degli LLM nel 2026
Il fine-tuning nel 2026 opera in un ambiente fondamentalmente diverso rispetto al 2024. I modelli base sono più grandi e più capaci, il che significa che il fine-tuning spesso raggiunge risultati eccellenti con meno esempi. L'addestramento consapevole della quantizzazione è maturato al punto che i modelli fine-tuned a 4 bit sono competitivi con le controparti a piena precisione. I metodi di allineamento post-addestramento come DPO e GRPO hanno in gran parte sostituito RLHF per l'apprendimento delle preferenze, e gli strumenti si sono adeguati.
Il panorama hardware è cambiato anch'esso. Le H200 di NVIDIA e l'AMD MI300X hanno reso accessibile la VRAM da 80GB+ negli ambienti cloud, mentre la RTX 5090 con 32GB è diventata la scheda di addestramento consumer di riferimento. L'addestramento multi-GPU tramite FSDP è diventato l'approccio standard, sostituendo DeepSpeed per molti carichi di lavoro grazie alla sua integrazione più stretta con PyTorch.
Sul lato dei modelli, l'ecosistema a pesi aperti è esploso. Llama 4, Mistral Large 2, Qwen 3 e DeepSeek-V3 forniscono tutti modelli base solidi per il fine-tuning. La copertura del supporto modelli di ogni framework è diventata un differenziatore chiave.
Panoramica dei Framework
Axolotl
Axolotl è iniziato come progetto comunitario per semplificare il fine-tuning multi-metodo ed è cresciuto fino a diventare il framework più completo in termini di funzionalità nell'ecosistema. Avvolge Hugging Face Transformers e PEFT, aggiungendo un sistema di configurazione basato su YAML che copre virtualmente ogni parametro di addestramento. Il punto di forza di Axolotl è l'ampiezza: supporta più metodi di addestramento, architetture di modelli e formati di dataset di qualsiasi altro singolo framework.
Unsloth
Unsloth adotta l'approccio opposto ad Axolotl. Invece di avvolgere lo stack Hugging Face, Unsloth reimplementa i kernel di addestramento critici usando Triton, raggiungendo accelerazioni di 2-5x rispetto alle implementazioni standard. Si concentra inesorabilmente sulle prestazioni su singola GPU e l'efficienza della memoria, rendendolo il framework di scelta per i professionisti che lavorano con budget hardware limitati.
TorchTune
TorchTune è il framework ufficiale di fine-tuning di Meta, costruito da zero su primitive native PyTorch. Evita le dipendenze esterne dove possibile, usando torch.compile, DTensor e FSDP2 invece di librerie di terze parti. Questo gli conferisce l'integrazione più stretta con l'ecosistema PyTorch e il comportamento più prevedibile su nuove release di PyTorch.
TRL
TRL, mantenuto da Hugging Face, è la libreria standard per l'apprendimento per rinforzo da feedback umano e metodi di post-addestramento correlati. Sebbene supporti SFT, il suo punto di forza principale è l'addestramento di allineamento: DPO, GRPO, KTO, ORPO e l'intera famiglia di metodi di ottimizzazione delle preferenze. Se il tuo carico di lavoro principale è l'allineamento piuttosto che il fine-tuning supervisionato, TRL è il punto di partenza naturale.
LLaMA-Factory
LLaMA-Factory fornisce un'interfaccia web e CLI per il fine-tuning con enfasi sull'accessibilità. Avvolge Hugging Face Transformers e supporta un'ampia gamma di metodi e modelli. La sua interfaccia web lo rende popolare per i team che vogliono democratizzare il fine-tuning oltre il team di ingegneria ML.
Architettura e Filosofia di Design
Le differenze architetturali tra questi framework non sono superficiali. Riflettono credenze fondamentalmente diverse su come dovrebbe apparire l'esperienza dello sviluppatore di fine-tuning.
L'architettura di Axolotl è guidata dalla configurazione. Un singolo file YAML specifica tutto: il modello base, il tipo di adattatore, il formato del dataset, gli iperparametri di addestramento e le impostazioni hardware. Questo rende Axolotl estremamente riproducibile. Puoi dare a qualcuno un file YAML e può ricreare la tua esatta esecuzione di addestramento. Lo svantaggio è che lo spazio di configurazione è enorme, e la relazione tra le opzioni non è sempre ovvia:
base_model: meta-llama/Llama-4-Scout-17B-16E
model_type: AutoModelForCausalLM
tokenizer_type: AutoTokenizer
load_in_4bit: true
adapter: qlora
lora_r: 32
lora_alpha: 64
lora_dropout: 0.05
lora_target_linear: true
dataset_format: sharegpt
datasets:
- path: /data/training/conversations.jsonl
type: sharegpt
conversation: chatml
sequence_len: 8192
sample_packing: true
pad_to_sequence_len: true
gradient_accumulation_steps: 4
micro_batch_size: 2
num_epochs: 3
learning_rate: 2e-4
lr_scheduler: cosine
warmup_steps: 100
optimizer: adamw_bnb_8bit
bf16: auto
tf32: true
flash_attention: true
gradient_checkpointing: true
wandb_project: llama4-finetune
wandb_run_id: scout-qlora-v1
L'architettura di Unsloth è centrata su kernel Triton personalizzati che sostituiscono le implementazioni standard di PyTorch di attenzione, passaggi forward LoRA e calcolo della perdita. L'API è intenzionalmente minimale:
from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained(
model_name="meta-llama/Llama-4-Scout-17B-16E",
max_seq_length=8192,
dtype=None,
load_in_4bit=True,
)
model = FastLanguageModel.get_peft_model(
model,
r=32,
target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj"],
lora_alpha=64,
lora_dropout=0,
bias="none",
use_gradient_checkpointing="unsloth",
random_state=42,
)
TorchTune usa un'architettura basata su ricette. Ogni metodo di addestramento è uno script Python autonomo (una "ricetta") che puoi leggere, comprendere e modificare. La configurazione usa file TOML:
[model]
_component_ = "torchtune.models.llama4.llama4_scout_17b_16e"
[tokenizer]
_component_ = "torchtune.models.llama4.llama4_tokenizer"
path = "/models/llama4-scout/tokenizer.model"
[dataset]
_component_ = "torchtune.datasets.chat_dataset"
source = "/data/training/conversations.jsonl"
conversation_style = "sharegpt"
[optimizer]
_component_ = "torch.optim.AdamW"
lr = 2e-4
weight_decay = 0.01
[training]
batch_size = 2
epochs = 3
gradient_accumulation_steps = 4
compile = true
TRL segue il pattern Hugging Face Trainer, estendendolo con trainer specializzati per ogni metodo di allineamento:
from trl import SFTTrainer, SFTConfig
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig
model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Llama-4-Scout-17B-16E",
torch_dtype="auto",
attn_implementation="flash_attention_2",
)
training_args = SFTConfig(
output_dir="./output",
per_device_train_batch_size=2,
gradient_accumulation_steps=4,
num_train_epochs=3,
learning_rate=2e-4,
lr_scheduler_type="cosine",
warmup_steps=100,
bf16=True,
max_seq_length=8192,
packing=True,
gradient_checkpointing=True,
)
peft_config = LoraConfig(
r=32,
lora_alpha=64,
lora_dropout=0.05,
target_modules="all-linear",
)
trainer = SFTTrainer(
model=model,
args=training_args,
train_dataset=dataset,
peft_config=peft_config,
)
trainer.train()
Supporto dei Metodi di Addestramento
La gamma dei metodi di addestramento supportati varia significativamente tra i framework. Ecco la matrice di supporto attuale:
SFT (Supervised Fine-Tuning) è supportato da tutti e cinque i framework. Questo è il requisito minimo. Le differenze emergono nell'efficienza con cui ogni framework implementa SFT, in particolare riguardo al sample packing, al parallelismo di sequenza e all'ottimizzazione della memoria.
DPO (Direct Preference Optimization) è pienamente supportato da TRL, Axolotl e LLaMA-Factory. TorchTune ha aggiunto il supporto DPO alla fine del 2025. Unsloth supporta DPO attraverso il suo layer di integrazione TRL.
GRPO (Group Relative Policy Optimization) è emerso come il metodo di allineamento preferito per i modelli di ragionamento dopo il lavoro di DeepSeek. TRL ha l'implementazione GRPO più matura. Axolotl lo supporta attraverso la delega a TRL. TorchTune ha GRPO nativo dall'inizio del 2026.
RLHF con PPO rimane supportato in TRL ma è caduto in disuso per la maggior parte dei casi d'uso. La complessità e l'instabilità dei cicli di addestramento PPO hanno reso DPO e GRPO alternative attraenti.
QAT (Quantization-Aware Training) è supportato nativamente in TorchTune attraverso le primitive di quantizzazione di PyTorch. Unsloth supporta QAT attraverso i suoi kernel personalizzati. Axolotl e TRL supportano QAT tramite integrazione con bitsandbytes e GPTQ.
Confronto delle Prestazioni su Singola GPU
Le prestazioni su singola GPU sono l'area in cui i framework mostrano le differenze più drammatiche. Abbiamo valutato tutti e quattro su un fine-tune QLoRA di Llama 3.1 8B usando lo stesso dataset, iperparametri e hardware (NVIDIA A100 80GB).
Configurazione di addestramento: QLoRA r=32, lunghezza di sequenza 4096, dimensione del batch 2, accumulazione del gradiente 4, 1000 passi, precisione BF16.
Unsloth offre costantemente l'addestramento più veloce su singola GPU, tipicamente 2-3x più veloce di TRL sulla stessa configurazione. L'accelerazione proviene da tre fonti: kernel Triton fusi che combinano operazioni multiple in singoli lanci di kernel GPU, un'implementazione LoRA personalizzata che evita di materializzare tensori intermedi a rango pieno, e un'implementazione ottimizzata del gradient checkpointing che riduce la ricomputazione.
TorchTune con torch.compile abilitato raggiunge circa 1,5x di accelerazione rispetto a TRL su esecuzioni di addestramento più lunghe, sebbene il passo di compilazione aggiunga diversi minuti di overhead di avvio. Per esecuzioni brevi di fine-tuning sotto i 30 minuti, questo costo di compilazione può annullare il miglioramento del tempo di esecuzione.
Le prestazioni di Axolotl sono essenzialmente identiche a TRL per configurazioni equivalenti perché usa lo stesso ciclo di addestramento sottostante di Hugging Face. Il valore di Axolotl sta nella comodità di configurazione piuttosto che nella velocità pura.
L'efficienza della memoria segue uno schema simile. I kernel personalizzati di Unsloth riducono l'utilizzo di picco della memoria del 30-50% rispetto alle implementazioni standard, spesso permettendo di addestrare su una singola GPU dove altri framework richiederebbero l'offloading del gradiente o una scheda più grande.
Scalabilità Multi-GPU
Per l'addestramento multi-GPU, il panorama cambia. TorchTune ha la storia multi-GPU più forte perché costruisce direttamente sulle primitive FSDP2 e DTensor di PyTorch:
tune run --nproc_per_node 8 full_finetune_distributed \
--config llama4_scout/17B_full.toml
TRL e Axolotl usano Hugging Face Accelerate per l'addestramento distribuito, che avvolge FSDP o DeepSpeed:
accelerate launch --num_processes 8 \
--mixed_precision bf16 \
--use_fsdp \
--fsdp_sharding_strategy FULL_SHARD \
train.py
Il supporto multi-GPU di Unsloth è stato storicamente la sua area più debole. I kernel Triton personalizzati sono stati progettati per l'esecuzione su singola GPU, e sebbene il supporto multi-GPU sia migliorato nel corso del 2025 e 2026, richiede ancora più configurazione manuale rispetto alle alternative.
Per esecuzioni di addestramento su larga scala attraverso nodi multipli, TorchTune e l'integrazione DeepSpeed in TRL/Axolotl sono le opzioni più collaudate. Il vantaggio di TorchTune è che evita i problemi di compatibilità delle versioni che a volte sorgono tra Accelerate, DeepSpeed e Transformers.
Configurazione ed Esperienza dello Sviluppatore
L'esperienza dello sviluppatore si estende oltre la configurazione iniziale per comprendere debug, riproducibilità e curva di apprendimento per i nuovi membri del team.
La configurazione YAML di Axolotl è simultaneamente la sua più grande forza e debolezza. Un singolo file YAML specifica completamente un'esecuzione di addestramento, rendendo la riproduzione banale. Tuttavia, i file YAML possono crescere fino a centinaia di righe, e la documentazione per le opzioni meno comuni è talvolta incompleta. Il debug di un problema di configurazione spesso significa cercare nelle issue di GitHub.
Unsloth fornisce l'esperienza più Pythonica. La configurazione è codice, il che significa che il tuo IDE fornisce autocompletamento e controllo dei tipi. La curva di apprendimento è dolce per chiunque abbia familiarità con PyTorch. Lo svantaggio è che la riproducibilità richiede la condivisione di script Python piuttosto che di file di configurazione dichiarativi.
TorchTune trova un punto intermedio con la sua configurazione TOML più architettura a ricette. Le ricette sono file Python leggibili che servono sia come codice eseguibile che come documentazione. Quando qualcosa va storto, puoi leggere il codice sorgente della ricetta e capire il flusso di esecuzione. Questa trasparenza è preziosa per i team che hanno bisogno di capire e modificare il processo di addestramento.
TRL segue il familiare pattern del Hugging Face Trainer. Se il tuo team usa già Hugging Face per l'inferenza e l'elaborazione dei dati, TRL richiede il minor apprendimento nuovo. Il pattern TrainingArguments è ben documentato e ampiamente compreso.
Tecniche di Ottimizzazione della Memoria
L'efficienza della memoria determina se puoi addestrare sull'hardware che hai. Ogni framework offre tecniche diverse:
# Unsloth: automatic memory-efficient LoRA
model = FastLanguageModel.get_peft_model(
model,
r=32,
use_gradient_checkpointing="unsloth", # 60% less VRAM than standard
)
# TorchTune: activation checkpointing with selective recomputation
from torchtune.training import ActivationCheckpointing
model = ActivationCheckpointing(model, checkpoint_every_n_layers=2)
Il gradient checkpointing è universalmente supportato, ma le implementazioni differiscono. L'implementazione di Unsloth è la più efficiente in termini di memoria, ricomputando selettivamente solo le operazioni più economiche. L'implementazione di TorchTune è la più configurabile, permettendo granularità a livello di layer.
Il CPU offloading sposta gli stati dell'ottimizzatore nella RAM della CPU, riducendo drasticamente i requisiti di memoria GPU a costo della velocità di addestramento. TRL e Axolotl supportano questo tramite DeepSpeed ZeRO Stage 3:
{
"zero_optimization": {
"stage": 3,
"offload_optimizer": {
"device": "cpu",
"pin_memory": true
},
"offload_param": {
"device": "cpu",
"pin_memory": true
}
}
}
Gli ottimizzatori quantizzati sostituiscono Adam standard con varianti a 8 bit o 4 bit che usano una frazione della memoria. Tutti i framework supportano Adam a 8 bit di bitsandbytes. Unsloth offre adizionalmente implementazioni personalizzate di ottimizzatori quantizzati.
Quando Usare Quale: Matrice Decisionale
La scelta del framework dovrebbe essere guidata dai tuoi requisiti specifici piuttosto che dai titoli dei benchmark.
Scegli Unsloth quando lavori con una singola GPU e hai bisogno della massima velocità di addestramento ed efficienza della memoria. Unsloth è il chiaro vincitore per professionisti individuali, piccoli team e qualsiasi scenario in cui stai addestrando su hardware consumer o una singola GPU cloud. Se stai eseguendo QLoRA su una RTX 4090 o una singola A100, Unsloth ti ci porterà più velocemente.
Scegli TorchTune quando hai bisogno di full fine-tuning multi-GPU con l'integrazione PyTorch più stretta possibile. TorchTune è la scelta giusta per team che eseguono lavori di addestramento su larga scala, necessitano di riproducibilità tra versioni di PyTorch e vogliono minimizzare le dipendenze esterne. È anche la scelta migliore se stai facendo fine-tuning dei modelli Llama di Meta, poiché riceve supporto di prima parte per le nuove architetture Llama.
Scegli TRL quando il tuo carico di lavoro principale è l'addestramento di allineamento (DPO, GRPO, KTO, ORPO). TRL ha l'implementazione più matura e completa dei metodi di ottimizzazione delle preferenze. È anche la scelta naturale se il tuo workflow è profondamente integrato con l'ecosistema Hugging Face.
Scegli Axolotl quando hai bisogno della massima flessibilità in un singolo strumento. Axolotl supporta più architetture di modelli, metodi di addestramento e formati di dataset di qualsiasi altro framework. È la scelta giusta per team che addestrano molti modelli diversi e hanno bisogno di un'interfaccia unica e coerente.
Scegli LLaMA-Factory quando devi permettere a non-ingegneri ML di eseguire lavori di fine-tuning. La sua interfaccia web abbassa significativamente la barriera all'ingresso, e la sua CLI è semplice per workflow scriptati.
Preparazione dei Dataset e Gestione dei Formati
Uno degli aspetti più sottovalutati nella scelta di un framework di fine-tuning è come gestisce la preparazione dei dataset. I dati di addestramento del mondo reale sono disordinati, inconsistenti e raramente nel formato esatto che un framework si aspetta di default.
Axolotl eccelle qui con supporto per oltre una dozzina di formati di dataset, includendo ShareGPT, Alpaca, completamenti chat OpenAI, JSONL con mappature di campi personalizzate e formati di completamento grezzi. La sua pipeline di preprocessing dei dataset gestisce tokenizzazione, applicazione di template chat e sample packing in un singolo passaggio:
datasets:
- path: /data/sharegpt_conversations.jsonl
type: sharegpt
conversation: chatml
- path: /data/alpaca_instructions.jsonl
type: alpaca
- path: /data/completions.jsonl
type: completion
field_instruction: prompt
field_output: response
TRL usa la libreria standard di dataset Hugging Face e si aspetta dati in formato conversazionale con array di messaggi. Convertire formati personalizzati richiede di scrivere una funzione di preprocessing:
from datasets import load_dataset
def format_conversations(example):
messages = []
for turn in example["conversation"]:
messages.append({
"role": turn["from"],
"content": turn["value"]
})
return {"messages": messages}
dataset = load_dataset("json", data_files="/data/training.jsonl")
dataset = dataset.map(format_conversations)
Unsloth delega la gestione dei dataset all'utente, fornendo funzioni helper per formati comuni ma aspettandosi che tu gestisca il preprocessing da solo. Questo dà massima flessibilità a costo di più codice boilerplate.
TorchTune fornisce builder di dataset per formati comuni e enfatizza la sicurezza dei tipi nella costruzione dei dataset. Le sue classi di dataset validano la struttura di ogni esempio prima dell'addestramento, rilevando problemi di formato presto piuttosto che durante una lunga esecuzione di addestramento.
Il sample packing, dove più esempi brevi vengono concatenati in una singola sequenza per massimizzare l'utilizzo della GPU, è un'ottimizzazione critica per dataset con esempi di lunghezza variabile. Axolotl e TRL supportano il sample packing nativamente. Unsloth implementa il proprio algoritmo di packing ottimizzato. TorchTune ha aggiunto il sample packing a metà 2025 e la sua implementazione gestisce correttamente i casi limite come il mascheramento dell'attenzione cross-esempio.
Valutazione e Benchmarking Durante l'Addestramento
Valutare la qualità del modello durante l'addestramento è essenziale per rilevare l'overfitting, selezionare il miglior checkpoint e confrontare le esecuzioni. Ogni framework affronta la valutazione durante l'addestramento in modo diverso.
TRL fornisce l'integrazione di valutazione più fluida perché si basa sul Hugging Face Trainer, che supporta dataset di valutazione, callback di metriche personalizzate e selezione automatica del miglior checkpoint:
from trl import SFTConfig
training_args = SFTConfig(
output_dir="./output",
evaluation_strategy="steps",
eval_steps=100,
save_strategy="steps",
save_steps=100,
load_best_model_at_end=True,
metric_for_best_model="eval_loss",
per_device_eval_batch_size=4,
)
Axolotl supporta la valutazione attraverso la sua configurazione YAML con opzioni simili per frequenza di valutazione, selezione delle metriche e gestione dei checkpoint. Supporta inoltre l'early stopping basato sulle metriche di valutazione:
eval_steps: 100
save_steps: 100
eval_batch_size: 4
early_stopping_patience: 5
load_best_model_at_end: true
L'architettura a ricette di TorchTune significa che la logica di valutazione vive nel file Python della ricetta stessa, dandoti pieno controllo su quali metriche vengono calcolate e quando. Puoi aggiungere logica di valutazione personalizzata, eseguire suite di benchmark, o anche generare output campione durante l'addestramento:
# Inside a TorchTune recipe
if step % eval_interval == 0:
model.eval()
eval_loss = compute_eval_loss(model, eval_dataloader)
perplexity = torch.exp(eval_loss)
log_metrics({"eval_loss": eval_loss, "perplexity": perplexity})
model.train()
Unsloth non include hook di valutazione integrati, affidandosi all'utente per implementare la valutazione esternamente o usare Unsloth all'interno di un TRL SFTTrainer dove si applica l'infrastruttura di valutazione di TRL.
Per l'addestramento di allineamento specificamente, la valutazione è più sfumata delle curve di perdita. TRL supporta la valutazione del tasso di vittoria contro un modello di riferimento durante l'addestramento DPO, fornendo una misura diretta di se il modello allineato sta migliorando nella direzione prevista.
Considerazioni sul Deployment in Produzione
Il fine-tuning è prezioso solo se il modello risultante può essere distribuito in modo affidabile. Ogni framework ha storie diverse di esportazione e deployment.
Tutti i framework esportano formati di modello standard Hugging Face, che possono essere serviti da vLLM, TGI o qualsiasi framework di inferenza che supporti il formato del model hub Hugging Face. Gli adattatori LoRA possono essere fusi nel modello base prima del deployment o serviti separatamente usando framework che supportano il caricamento dinamico degli adattatori.
Unsloth fornisce esportazione GGUF ottimizzata per il deployment con llama.cpp e Ollama:
model.save_pretrained_gguf(
"output_model",
tokenizer,
quantization_method="q4_k_m"
)
TorchTune si integra con ExecuTorch per il deployment mobile e edge, che è un vantaggio unico se i tuoi target di deployment si estendono oltre i server cloud.
Per pipeline di addestramento in produzione, considera la containerizzazione del tuo workflow di addestramento:
docker run --gpus all -v /data:/data -v /models:/models \
axolotl-train:latest \
accelerate launch -m axolotl.cli.train /data/config.yaml
Fissa le versioni del tuo framework, PyTorch e del toolkit CUDA. I risultati di addestramento possono variare significativamente tra versioni, e il debug della non riproducibilità tra ambienti è uno dei problemi più dispendiosi in termini di tempo nelle operazioni ML.
Qualunque framework tu scelga, investi nel tracking degli esperimenti dal primo giorno. Weights and Biases, MLflow, o anche una directory di log strutturata ti risparmieranno ore di confusione quando dovrai confrontare i risultati tra esecuzioni di addestramento. Tutti i framework supportano l'integrazione W&B, e i metadati che cattura (configurazione, hardware, curve di addestramento, metriche di valutazione) sono essenziali per prendere decisioni informate sulla qualità del modello e l'efficienza dell'addestramento.