Prendere un modello linguistico pre-addestrato e adattarlo al proprio compito è diventato l'operazione più comune nell'AI applicata. Non più ricerca: ingegneria quotidiana. L'articolo spiega cos'è il fine-tuning, come nasce Unsloth AI, cosa lo rende tecnologicamente diverso dagli alternativi open-source, e quando ha senso usarlo al posto di Axolotl, LLaMA-Factory o TRL.
Cos'è il fine-tuning
Un modello linguistico come Llama, Qwen o Gemma viene pre-addestrato su centinaia di miliardi di token. Riconosce la struttura della lingua, ma non sa nulla del tuo dominio specifico: il formato dei tuoi log, il tono della tua documentazione, le convenzioni del tuo codice.
Il fine-tuning aggiorna i pesi del modello su un dataset più piccolo e mirato. Il pre-training insegna a parlare; il fine-tuning insegna a parlare del tuo problema.
PRE-TRAINING FINE-TUNING
┌─────────────────┐ ┌─────────────────┐
│ Miliardi di │ │ Migliaia di │
│ token generici │ ──────────► │ esempi dominio │
│ (libri, web) │ │ (tuoi dati) │
└─────────────────┘ └─────────────────┘
│ │
▼ ▼
Modello base Modello specializzato
"sa parlare" "sa parlare di te"
Esistono tre famiglie di metodi, ordinate per costo computazionale:
Full fine-tuning: aggiorna tutti i pesi. Massima flessibilità, massimo costo. Servono decine di GB di VRAM anche per modelli piccoli.
LoRA (Low-Rank Adaptation): congela i pesi originali e allena solo piccole matrici di basso rango. Circa il 90% dei parametri restano congelati; il costo cala di un ordine di grandezza.
QLoRA: LoRA con il modello base quantizzato a 4 bit. Il modello base occupa un quarto dello spazio; su una GPU da 24 GB permette di addestrare modelli da 13B che altrimenti non entrerebbero.
Unsloth si concentra su LoRA e QLoRA, estendendo recentemente al full fine-tuning e al reinforcement learning (DPO, GRPO).
La storia di Unsloth
Unsloth nasce nel 2023 come progetto open-source di Daniel e Michael Han, due fratelli australiani. Daniel aveva lavorato come machine learning engineer a NVIDIA, dove si era occupato di ottimizzare algoritmi computazionali; il suo profilo Y Combinator riporta anche di aver trovato e corretto più di 20 bug in modelli open-source come Gemma, Llama, Mistral e Phi.
L'idea è semplice e parte da un'osservazione che chi ha addestrato modelli conosce bene: la maggior parte del tempo di training non è spesa a fare matematica utile, ma a far attivare e disattivare la memoria GPU per operazioni che possono essere riscritte in modo più efficiente.
2023 ─────────────────────────────────────────────────────────
│ Progetto open-source nato in Australia
│ "Rendere il fine-tuning su una sola GPU accessibile"
│
2024 ─────────────────────────────────────────────────────────
│ Y Combinator Summer 2024 (batch S24)
│ Seed round da ~$500K (YC, GitHub Accelerator, Microsoft M12)
│ Daniel pubblica bug report dettagliati su Llama, Gemma, Mistral
│
2025 ─────────────────────────────────────────────────────────
│ Febbraio: GRPO + integrazione vLLM (training e inference
│ sulla stessa GPU)
│ Agosto: supporto per gpt-oss 20B e 120B il giorno della
│ release (QLoRA su ~14 GB di VRAM)
│ Dicembre: padding-free training, sequence packing,
│ supporto preliminare multi-GPU (DDP)
│ "3x più veloce, -30% VRAM" rispetto alla release precedente
│
2026 ─────────────────────────────────────────────────────────
│ Febbraio: MoE training support, embedding model support,
│ ultra-long context RL. Oltre 50K stelle GitHub.
│ Marzo: Unsloth Studio, interfaccia desktop e web
│ "2-5x più veloce, -70-80% VRAM" vs training standard HF
Oggi Unsloth riporta oltre 10 milioni di download mensili su Hugging Face, adozione da parte di team come Canva, LinkedIn e NVIDIA, e oltre 500 varianti di modelli supportate.
Come funziona: la differenza tecnica
La maggior parte dei framework di fine-tuning — Axolotl, LLaMA-Factory, TRL — sono wrapper su PyTorch e Hugging Face Transformers. Agggiungono configurazione, metodi di training, gestione dei dataset, ma il calcolo sottostante è quello di PyTorch con autograd.
Unsloth fa qualcosa di diverso: riscrive i kernel più pesanti del training loop in codice Triton hand-written.
Il problema che Unsloth risolve
Quando addestri un modello, il 70-80% del tempo è speso in poche operazioni:
- attention (e la sua inversa nel backward pass)
- rotary position embeddings (RoPE)
- RMS normalization
- cross-entropy loss
- GELU e altre funzioni di attivazione
Questi operazioni sono implementate in PyTorch con operazioni elementari che creano e distruggono tensori intermedi. Ogni operazione legge e scrive la VRAM. Il calcolo matematico è minimo; il movimento dei dati è enorme.
PYTORCH STANDARD UNSLOTH (TRITON)
┌──────────────────────┐ ┌──────────────────────┐
│ x ──► [read VRAM] │ │ x ──► [register] │
│ [compute] │ │ [compute] │
│ [write VRAM] │ │ [compute] │
│ │ │ │ [write VRAM] │
│ ▼ │ │ │
│ y ──► [read VRAM] │ │ Un solo kernel, │
│ [compute] │ │ un solo passaggio │
│ [write VRAM] │ │ sulla memoria │
│ │ │ │ │
│ ▼ │ └──────────────────────┘
│ ... │
└──────────────────────┘
Un singolo kernel sostitutivo in Triton per la sequenza completa significa: un solo passaggio dalla VRAM invece di cinque, e i valori intermedi restano nei registri della GPU. La VRAM si libera dopo invece di essere tenuta da tensore a tensore.
Perché non perde accuracy
Un punto che distingue Unsloth da altre ottimizzazioni (es. Mixed Precision Training): non introduce approssimazioni numeriche. La matematica è identica a quella di PyTorch standard; solo l'implementazione è diversa.
Hugging Face stessa ha verificato che l'accuracy degradation è 0% rispetto a QLoRA standard. Questo non è vero per tutte le ottimizzazioni di memoria: alcune tecniche (es. gradient checkpointing aggressivo o quantizzazione a basso bit) introducono perdite misurabili. Unsloth evita questo trading-off.
Cosa supporta oggi
Metodi: LoRA, QLoRA, full fine-tuning, DPO, GRPO, KTO, ORPO, continued pre-training, pretraining
- Precisione: FP8 training (da fine 2025), BF16, FP16
Modelli: 500+ varianti — Gemma, Qwen, DeepSeek, Llama, Mistral, gpt-oss, e molti altri
- Hardware: NVIDIA (CUDA), AMD (ROCm), Intel GPU
Contesto: fino a 342,733 token su GPU da 80 GB (vs 28,454 con Transformers standard)
Multi-GPU: supporto preliminare DDP (Distributed Data Parallel), FSDP — 2026 ha visto i primi rilasci, ma non è ancora al livello di Axolotl o LLaMA-Factory
Il confronto con i concorrenti
Quattro progetti open-source dominano il fine-tuning locale nel 2026. Tutti sono gratuiti e Apache 2.0. Differiscono su dove spendono l'ingegneria.
Tabella riassuntiva
| Unsloth | Axolotl | LLaMA-Factory | TRL |
|---|---|---|---|
| Stelle GitHub (2026) | 53.9K | 11.4K | 68.4K |
| Metodo principale | Triton kernels | Composizione parallelismo | Web UI + copertura |
| LoRA / QLoRA | ✓ | ✓ | ✓ |
| Full fine-tuning | ✓ | ✓ | ✓ |
| DPO / GRPO / RL | ✓ | ✓ | ✓ |
| Multi-GPU maturo | Parziale (DDP) | ✓ (DeepSpeed, FSDP) | ✓ (DeepSpeed, FSDP) |
| Config YAML | ✗ (Python) | ✓ (estensivo) | ✓ |
| Web UI | ✗ (Studio separato) | ✗ | ✓ (LlamaBoard) |
| VRAM saving (claim) | 40-80% | Varia | Varia |
| Speedup (claim) | 2-5x | 1-1.5x | 1-1.2x |
VRAM e velocità: numeri reali
Misurazione su Llama 3.1 8B, QLoRA, batch 1, contesto 1024, RTX 4090 (24 GB VRAM):
| Framework | VRAM usata | Tokens/sec |
|---|---|---|
| Baseline (HF + PEFT) | 18 GB | 1,200 |
| Unsloth | 11 GB | 3,400 |
| Axolotl | 16 GB | 1,500 |
| LLaMA-Factory | 17 GB | 1,400 |
Su singola GPU il divario è chiaro: Unsloth usa meno memoria e traina più del doppio rispetto al baseline. Il vantaggio si riduce su multi-GPU, dove le strategie di parallelismo di Axolotl e LLaMA-Factory (DeepSpeed ZeRO, FSDP, tensor parallelism) fanno la differenza.
Axolotl: la flessibilità configurabile
Axolotl è il framework più configurabile quattro. Tutto si definisce in un file YAML: strategie di parallelismo (FSDP2, DeepSpeed ZeRO, tensor parallelism, context parallelism, expert parallelism), metodi di training, quantizzazione, e gestione dataset.
Il suo punto di forza è il multi-GPU maturo. Se devi addestrare su 8 H100 e comporre DeepSpeed ZeRO Stage 3 con FSDP e tensor parallelism, Axolotl ha già la configurazione pronta. Su 8 H100 con Llama 3.1 8B, Axolotl raggiunge contesti di 129,024 token, anche se l'efficienza per GPU scende al 15%.
Il prezzo è la velocità su singola GPU: Axolotl non riscrive kernel, quindi sta ai tempi di PyTorch standard con l'overhead del wrapper.
Quando sceglierlo: multi-GPU, configurazioni complesse, ricerca dove il file di configurazione è l'artefatto che si versiona e si riproduce.
LLaMA-Factory: la copertura e la web UI
LLaMA-Factory ha la più ampia copertura di modelli: 100+ LLM e VLM, compatibilità con architetture che gli altri non supportano. Offre una web interface (LlamaBoard) per gestire training, valutazione e export senza scrivere codice.
È la scelta più accessibile per team non specialistici. L'integrazione con Megatron-Core apre la porta al pre-training su larga scala, ma la curva di apprendimento diventa ripida.
Quando sceglierlo: vuoi una web UI, hai bisogno di supporto per un modello o una architettura esotica, o fai continued pre-training e non solo fine-tuning.
TRL: l'ecosistema Hugging Face
TRL (Transformer Reinforcement Learning) è il trainer API ufficiale di Hugging Face per RLHF, DPO, GRPO e PPO. Non è un framework autonomo: è la libreria su cui gli altri si appoggiano quando fanno reinforcement learning.
Il suo valore è la standardizzazione: se usi TRL, il codice è portabile su altri framework. Se fai ricerca su nuovi metodi di allineamento, TRL è dove vengono implementati per la prima volta.
Quando sceglierlo: fai ricerca su RLHF, hai bisogno di integrazione stretta con l'ecosistema Hugging Face, o vuoi massima portabilità.
Quando usare Unsloth
Unsloth non è la scelta migliore in ogni situazione. Ecco quando ha senso e quando no.
Usa Unsloth quando:
Hai una sola GPU (12-24 GB VRAM): è il caso d'uso per cui è stato progettato. Il vantaggio in velocità e VRAM è massimo.
Fai LoRA o QLoRA: le ottimizzazioni sono più efficaci su questi metodi che sul full fine-tuning.
Vuoi la massima velocità: 2-5x più veloce del baseline si traduce in meno tempo di attesa e meno costo di compute (se usi GPU cloud).
- Ti servono contesti lunghi: il supporto ultra-long context è nativo.
Hai una GPU consumer: funziona su RTX 3090, 4090, e su GPU più modeste (3-4 GB) grazie alla quantizzazione aggressiva.
Non usare Unsloth quando:
Devi fare multi-GPU serio: Axolotl e LLaMA-Factory hanno anni di maturità su DeepSpeed, FSDP, tensor parallelism. Unsloth ha DDP preliminare e FSDP di base.
Ti serve una web UI: LLaMA-Factory ha LlamaBoard; Unsloth Studio è un prodotto separato e ancora giovane.
Fai ricerca su nuovi metodi RL: TRL ha la primissima implementazione e la maggiore integrazione con Hugging Face.
Hai bisogno di configurazione YAML dichiarativa: Unsloth è Python-native; il tuo training script è codice, non un file di configurazione.
Esempio pratico: primo addestramento
Un esempio minimo per capire la sintassi. Addestri un modello Qwen2.5-0.5B su un dataset di esempio con QLoRA.
# install: pip install unsloth
from unsloth import FastLanguageModel
# 1. Carica il modello base quantizzato a 4 bit
model, tokenizer = FastLanguageModel.from_pretrained(
model_name="unsloth/Qwen2.5-0.5B-Instruct-bnb-4bit",
max_seq_length=2048,
load_in_4bit=True,
)
# 2. Configura QLoRA: congela i pesi, allena gli adapter
model = FastLanguageModel.get_peft_model(
model=model,
r=16, # rank delle matrici LoRA
lora_alpha=16, # scala del learning rate LoRA
lora_dropout=0,
target_modules=[
"q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj"
],
bias="none",
)
# 3. Prepara il dataset nel formato instruct
# Il dataset deve avere una colonna "text" nel formato:
# "### Istruzione: ...\n### Risposta: ..."
from datasets import load_dataset
dataset = load_dataset("yahma/alpaca-cleaned", split="train[:1000]")
# 4. Addestra
from trl import SFTTrainer
from transformers import TrainingArguments
trainer = SFTTrainer(
model=model,
tokenizer=tokenizer,
train_dataset=dataset,
dataset_text_field="text",
max_seq_length=2048,
args=TrainingArguments(
per_device_train_batch_size=2,
gradient_accumulation_steps=4,
warmup_steps=5,
max_steps=100,
learning_rate=2e-4,
fp16=True,
logging_steps=1,
output_dir="outputs",
),
)
trainer.train()
# 5. Salva il modello (solo gli adapter, ~100 MB)
model.save_pretrained_gguf("outputs/gguf", tokenizer, quantization_method="q4_k_m")
Tre cose saltano all'occhio rispetto a un training PyTorch standard:
- La quantizzazione è integrata:
load_in_4bit=Truesenza passi separati. La configurazione LoRA è esplicita: scegli quali layer adattare con
target_modules, non un flag generico.L'export in GGUF è built-in: il formato per inference locale con llama.cpp è un comando, non un converter separato.
Il futuro: Unsloth Studio e il multi-GPU
Nel marzo 2026 Unsloth ha rilasciato Unsloth Studio, un'applicazione desktop e web che permette di fare costruzione di dataset, fine-tuning e inferenza locale senza scrivere codice. È stato accolto con interesse dalla community e ha raggiunto la home di Hacker News nel giorno del lancio.
Il supporto multi-GPU è la frontiera attuale. Il rilascio di dicembre 2025 ha
introdotto DDP e accelerate launch; il team ha dichiarato che un rilascio
più completo è previsto per il 2026. Ad oggi, se il tuo training ha bisogno
di più di due GPU, Unsloth è ancora al passo rispetto ad Axolotl e
LLaMA-Factory, ma il divario si sta riducendo.
Conclusioni
Unsloth non è un framework di fine-tuning in più: è un'ottimizzazione del cui sottostante che rende il fine-tuning su una sola GPU più accessibile di quanto non lo fosse con gli altri. I numeri su VRAM e velocità lo confermano, e l'assenza di perdita di accuratezza elimina il dubbio che le ottimizzazioni sacrifichino la qualità.
La scelta dipende dal contesto:
- Singula GPU, LoRA/QLoRA, massima velocità: Unsloth.
- Multi-GPU, configurazioni complesse: Axolotl.
- Web UI, copertura modelli esotici: LLaMA-Factory.
- Ricerca RLHF, portabilità: TRL.
Nessuno dei quattro è obsoleto o superiore in assoluto. Rispondono a esigenze diverse, e l'ecosistema ne è più ricco. Il valore di Unsloth è aver spostato il confine di cosa è fattibile su hardware consumer, e questo è un contributo che va oltre il benchmark.
Fonti
- Y Combinator — Unsloth AI (fondazione 2023, batch S24, profili fondatori)
- Startup Intros — Unsloth AI (fratelli Daniel e Michael Han, sede, investimenti)
- AIWiki — Unsloth (storia, release 2025, licenza Apache 2.0, funzionalita' tecniche)
- MarkTechPost — Unsloth vs Axolotl vs TRL vs LLaMA-Factory (confronto tecnico, metodo Triton vs wrapper)
- Local LLM — Unsloth vs Axolotl vs LLaMA-Factory (benchmark VRAM e tokens/sec su RTX 4090)
- AllThingsOpen — Fine-tuning is no longer just an AI research process (riferimenti VRAM, Unsloth Studio, stelle GitHub)