Hugging Face: LLM open-weight in 12 passi in 70 minuti (2026)

Introduzione al tutorial hf‑lab

Il 29 ottobre 2026 Mistral AI ha rilasciato i pesi di Mistral Large 4, un modello multimodale con circa un trilione di parametri, disponibile su Hugging Face. Da quel momento, chiunque voglia sperimentare un LLM open‑weight deve capire cosa scaricare, quanto spazio occupa, sotto quale licenza è distribuito e se l’hardware a disposizione è sufficiente. Anche se un trilione di parametri non entra in un portatile, il percorso da seguire è identico a quello di un modello da un miliardo di parametri.

Il progetto si chiama hf‑lab. È uno strumento da riga di comando in Python che:

• cerca modelli sull’Hub di Hugging Face,
• legge licenza e dimensioni prima del download,
• scarica una revisione fissata tramite hash,
• esegue il modello con la libreria transformers,
• lo mette alla prova con una batteria di test personalizzabili.

Il tutorial richiede dodici passi e circa 70 minuti, la maggior parte dei quali spesi ad attendere i download.

Contesto: Hugging Face e gli LLM open‑weight al 3 novembre 2026

Hugging Face è un servizio di hosting basato su repository Git. Ogni modello vive in un repository che contiene:

• pesi,
• file di configurazione,
• tokenizer,
• una model card che dichiara licenza, dati di addestramento e limiti d’uso.

Intorno a questo nucleo operano le librerie huggingface_hub e transformers, gli Spaces per le demo, e due modalità di inferenza senza download locale: gli Inference Providers (richieste instradate a fornitori terzi) e gli Inference Endpoints (macchine dedicate gestite da Hugging Face).

Il termine “open‑weight” indica che i pesi sono scaricabili, ma non che il modello sia open‑source secondo la definizione dell’Open Source Initiative. Mistral Large 4 è distribuito con la Mistral Ecosystem Open‑Weight License, una variante della licenza MIT che richiede una licenza commerciale separata per chi offre il modello come servizio via API. Per uso interno e ricerca, il percorso è libero.

Storia rapida di Mistral Large 4

Il modello ha avuto due “vite” in meno di un mese. Il 6 ottobre 2026 Mistral ha annunciato una public preview, poi il 29 ottobre ha rilasciato i pesi di produzione, includendo addestramento di rinforzo aggiuntivo. La versione preview è ora ritirata; i tutorial che la citano sono obsoleti. Il soprannome informale “Le Chonk”, ripreso da Cybernews, si riferisce al prodotto ufficiale Mistral Large 4.

Specifiche tecniche e varianti

Le fonti non coincidono del tutto sui numeri:

• Hugging Face descrive un modello Mixture‑of‑Experts con circa 1 trilione di parametri totali, 49 miliardi attivi e una finestra di contesto di 1 milione di token.
• Altre ricostruzioni indicano 52 miliardi di parametri attivi.

Il tutorial usa il valore totale (≈ 1 trilione) perché la differenza non influisce sul flusso di lavoro. Il rilascio include varianti FP8 e NVFP4, supportate fin dal primo giorno da transformers, vLLM e llama.cpp. Le conversioni GGUF della community (Unsloth, team di llama.cpp) sono lavori di terzi, non rilasci ufficiali di Mistral.

Confronti con altri modelli di fascia alta

Nel panorama cinese, DeepSeek ha pubblicato il modello V4.1 Flash il 10 settembre 2026, con comprensione visiva nativa. Il 17 ottobre è arrivato l’aggiornamento DeepSeek‑V4.1‑Flash‑1017. Su Hugging Face sono presenti repository corrispondenti, inclusa una variante NVFP4 di NVIDIA. La scheda modello indica un MoE multimodale con 552 miliardi di parametri e contesto fino a 1 milione di token.

Un confronto diretto tra Mistral Large 4, GPT‑6.1 (chiuso) e DeepSeek V4.1 Flash mette in evidenza prezzi, prestazioni e requisiti hardware. Un altro rilascio ottobre è Beam di Reflection, 501 miliardi di parametri totali con licenza Apache 2.0. Tutti questi modelli richiedono cluster di GPU, non una singola scrivania.

Perché imparare il metodo è più importante del modello

Il tutorial non punta a far girare direttamente il modello da un trilione di parametri, ma a insegnare un metodo replicabile:

• leggere i metadati,
• calcolare i requisiti di memoria,
• scaricare una revisione fissata,
• misurare le prestazioni.

Se riesci a valutare un modello da 1 miliardo di parametri in dieci minuti, saprai in cinque minuti se un modello da un trilione è alla tua portata.

Prerequisiti e versioni consigliate

Il progetto è cross‑platform: Linux, macOS e Windows 11 (consigliato WSL2 per gestire i collegamenti simbolici della cache di Hugging Face). Di seguito i requisiti minimi:

• Python 3.11+ (consigliata 3.12). Verifica con python3 --version.
• pip aggiornato e modulo venv della libreria standard.
• Ultime versioni stabili di huggingface_hub, transformers, accelerate, safetensors e torch. Congela le versioni con pip freeze per avere una “verità” riproducibile.
• RAM: almeno 16 GB per modelli fino a 3 miliardi di parametri in bf16; meno memoria richiede modelli sotto il miliardo.
• Spazio disco: 20 GB per i test del tutorial; la cache dei modelli può crescere rapidamente.
• GPU opzionale: una scheda NVIDIA con driver CUDA recenti accelera la generazione di un ordine di grandezza rispetto alla CPU. Apple Silicon è supportato tramite il backend MPS di PyTorch.
• Account gratuito Hugging Face per generare un token di accesso; il piano PRO (a partire da 9 USD/mese) non è necessario per questo tutorial.
• Connessione internet stabile: un modello da 3 miliardi in bf16 pesa circa 6 GB; un download interrotto richiede tempo per riprendere.

Nota: le librerie Hugging Face cambiano spesso nomi di parametri e comandi. Il login oggi è hf auth login (CLI hf), che ha sostituito il vecchio huggingface-cli. Se un esempio fallisce, la prima azione è aggiornare i pacchetti e consultare le note di rilascio.

Calcolare il peso del modello prima del download

Il primo passo pratico è stimare lo spazio su disco e la RAM necessaria. La formula di base è:

peso file ≈ numero di parametri × byte per parametro

La RAM necessaria in esecuzione è il peso più un margine (circa 20 %) per la KV‑cache, le attivazioni e il sistema operativo. Con contesti lunghi, la KV‑cache può superare il peso dei pesi stessi.

Precisione	Byte per parametro	1 miliardo di parametri	1 trilione di parametri
FP32	4	≈ 4 GB	≈ 4 TB
BF16 / FP16	2	≈ 2 GB	≈ 2 TB
FP8 / INT8	1	≈ 1 GB	≈ 1 TB
4 bit (INT4, NVFP4)	0,5	≈ 0,5 GB	≈ 0,5 TB

La tabella mostra perché Mistral Large 4 non può girare su un PC medio: anche nella variante FP8 il file supera il terabyte.

Paso 1 – Preparare l’ambiente

Crea un virtual environment e installa le librerie:

python3 -m venv hf‑lab‑env
source hf‑lab‑env/bin/activate   # su Windows: hf‑lab‑env\Scripts\activate
pip install --upgrade pip
pip install huggingface_hub transformers accelerate safetensors torch

Congela le versioni:

pip freeze > requirements.txt

Paso 2 – Autenticazione

Genera un token sul tuo profilo Hugging Face e autenticati:

hf auth login
incolla il token quando richiesto

Paso 3 – Ricerca del modello

Usa la CLI per elencare i modelli che contengono “mistral‑large‑4” e visualizzare metadati:

hf repo list | grep mistral-large-4
hf hub info mistral-ai/mistral-large-4

Verifica licenza, numero di parametri, dimensioni dei file e hash della revisione.

Paso 4 – Calcolare i requisiti

Con i dati ottenuti, calcola lo spazio su disco (ad es. FP8 ≈ 0,5 TB) e la RAM (peso + 20 %). Se la tua macchina non soddisfa i requisiti, considera di scaricare una variante più piccola o di utilizzare gli Inference Endpoints.

Paso 5 – Download della revisione fissata

Scarica la revisione specifica usando l’hash:

hf download mistral-ai/mistral-large-4 \
--revision  \
--local-dir ./mistral-large-4 \
--cache-dir ./hf_cache

Il flag --cache-dir evita duplicati su più progetti.

Paso 6 – Convertire i pesi (se necessario)

Se vuoi usare llama.cpp o vLLM, converti i pesi in formato GGUF:

python -m transformers.convertgraphto_gguf \
--model_path ./mistral-large-4 \
--output_path ./mistral-large-4.gguf \
--dtype fp8

Le conversioni sono gestite dalla community; verifica la compatibilità con la versione corrente di llama.cpp.

Paso 7 – Caricare il modello con Transformers

from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained(
"./mistral-large-4",
torch_dtype=torch.float8,   # o torch.bfloat16 a seconda della variante
device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained("./mistral-large-4")

Il parametro device_map="auto" distribuisce i layer su più GPU se disponibili.

Paso 8 – Test di generazione rapido

prompt = "Spiega la teoria delle stringhe in tre frasi."
inputs = tokenizer(prompt, return_tensors="pt")
outputs = model.generate(**inputs, maxnewtokens=50)
print(tokenizer.decode(outputs[0], skipspecialtokens=True))

Misura il tempo di latenza e il consumo di memoria con nvidia-smi o torch.cuda.memory_summary().

Paso 9 – Verifica della KV‑cache

Per contesti lunghi, genera un testo con più di 500 k token e osserva l’aumento della memoria:

outputs = model.generate(
**inputs,
maxnewtokens=500_000,
use_cache=True
)

Nota il picco di RAM: se supera il 20 % di margine, valuta di ridurre la finestra di contesto o usare la precisione INT4.

Paso 10 – Benchmark personalizzato

Crea una suite di test che includa:

• tempo medio di generazione per 1 k token,
• accuratezza su un set di domande di conoscenza generale,
• consumo di GPU (VRAM) e CPU.

Salva i risultati in un file benchmark.json per confronti futuri.

Paso 11 – Pulizia della cache

La cache di Hugging Face può occupare centinaia di GB. Pulisci i file non più necessari:

hf hub prune --cache-dir ./hf_cache --max-size 50GB

Paso 12 – Condivisione dei risultati

Pubblica il tuo model card aggiornato con:

hf repo create my-mistral-evaluation
git add benchmark.json README.md
git commit -m "Aggiunto benchmark su Mistral Large 4"
git push origin main

Altri utenti potranno replicare la tua procedura e confrontare i risultati.

Considerazioni finali e consigli pratici

Scaricare un LLM da un trilione di parametri è un’operazione di ingegneria più che di semplice download. I punti chiave da ricordare sono:

• verifica sempre licenza e restrizioni commerciali,
• calcola spazio su disco e RAM prima di avviare il download,
• usa una revisione hash‑fissata per garantire riproducibilità,
• scegli la precisione più adatta al tuo hardware (INT4/NVFP4 è la più leggera),
• monitora costantemente l’utilizzo di VRAM e la KV‑cache per evitare overflow.

Seguendo i dodici passi di hf‑lab, anche chi dispone di una workstation “modesta” può valutare rapidamente se un modello da un trilione di parametri è gestibile, o se è più sensato ricorrere a un servizio di Inference Endpoint. Il metodo è universale: leggendo metadati, facendo i conti, scaricando versioni fissate e testando con benchmark personalizzati, si ottiene una valutazione accurata in meno di un’ora.