🧙 Maestro Yoda Cap. 21 · Open source e HuggingFace

Puntata 224

Puntata 224 — Hub, Datasets, Spaces

Livello: 🧙 Maestro Yoda · Capitolo 21 · Open source e HuggingFace

Tre verbi: scaricare, caricare, mostrare. Tre prodotti: Hub, Datasets, Spaces. Una piattaforma. Se capisci la divisione del lavoro tra questi tre pilastri capisci il 90% di come si fa AI open source nel 2026.

una casa a tre piani in stile italiano fine ‘800. Piano terra “Hub — modelli”, piano primo “Datasets — dati”, soffitta “Spaces — demo”. Il facchino con l’emoji 🤗 sale e scende con un carico di file. Sotto: “stessa scala, tre destinazioni”

Perché tre prodotti distinti

Tecnicamente è tutto git LFS. Filosoficamente sono tre flussi separati:

  • Hub (Models) = la cosa che usi.
  • Datasets = la cosa con cui l’hai addestrata.
  • Spaces = la cosa che mostra cosa fa.

Stesso URL pattern (huggingface.co/{org}/{repo}), stesso meccanismo git push, ma viewer, indicizzazione, integrazione con le librerie sono ottimizzati per il caso d’uso. Vediamoli uno per uno.

Hub (Models)

Un repo modello tipo ha:

  • config.json — architettura, hidden size, num layers, vocab size.
  • tokenizer.json + tokenizer_config.json — il tokenizer (vedi puntata 206).
  • model.safetensors o shard (model-00001-of-00010.safetensors) — i pesi.
  • generation_config.json — default per model.generate().
  • README.md — model card con frontmatter YAML standardizzato.
  • chat_template.jinja (per modelli istruiti) — il template Jinja2 che formatta le conversazioni.

Il frontmatter della model card è machine-readable. Estratto da meta-llama/Llama-3.2-3B-Instruct:

---
library_name: transformers
license: llama3.2
language: [en, de, fr, it, pt, hi, es, th]
tags: [facebook, meta, pytorch, llama, llama-3]
pipeline_tag: text-generation
---

Queste tag alimentano:

  • Filtri di ricerca (?filter=text-generation&language=it).
  • Leaderboard (Open LLM Leaderboard pesca da qui).
  • Auto-detection di task per pipeline().

Le revisions

Ogni repo è un git repo. Quindi:

  • main è il default.
  • Branch e tag esistono (es. pr/12, v1.0).
  • Si scarica una revisione specifica: 
    AutoModel.from_pretrained("org/model", revision="v1.0")
  • I commit sono immutabili — se domani il maintainer “aggiusta” i pesi e fai un nuovo run, il vecchio hash punta ancora ai pesi vecchi (riproducibilità).

Discussion + PR

Ogni repo ha tab Community: discussioni (issues) e Pull Request sulle model card o sui pesi. Sì, puoi proporre un fix di tipo nei pesi via PR. Strano ma vero.

Datasets

Stessa struttura git, ma il contenuto è Parquet/Arrow (o JSON, CSV, image folder). Carichi un dataset in 3 righe:

from datasets import load_dataset
ds = load_dataset("HuggingFaceH4/ultrachat_200k", split="train_sft")

Sotto il cofano la libreria datasets:

  • Streaming: per dataset grossi (TB), non scarica tutto. Iterazione lazy file-by-file.
  • Mapping/filtering: ds.map(fn, num_proc=8) in parallelo, cache automatica su disco.
  • Format conversion: passa a torch, numpy, tf con ds.with_format("torch").
  • Splits: train/val/test gestiti come oggetti distinti.

Il viewer

Ogni dataset ha un viewer web che mostra a campione le righe. Per multimodali: thumbnail di immagini, player audio. Inestimabile per scartare al volo un dataset rumoroso senza scaricarlo.

Dataset card

Frontmatter analogo:

---
language: [it]
license: cc-by-sa-4.0
task_categories: [text-classification]
size_categories: [10K<n<100K]
---

Pattern d’uso 2026

I dataset più scaricati riflettono il momento storico:

  • HuggingFaceFW/fineweb + fineweb-edu — Common Crawl filtrato per pretraining (15T+ token).
  • bigcode/the-stack-v2 — codice per pretraining (3B file, ~67T token).
  • HuggingFaceH4/ultrachat_200k + HuggingFaceH4/ultrafeedback_binarized — SFT/DPO classici.
  • open-r1/OpenR1-Math-220k — traces di reasoning per distillation (post DeepSeek-R1).

Spaces

Una demo deployata gratis, in 3 minuti, con auto-deploy da git push. Tre runtime supportati:

  1. Gradio — Python, ottimo per ML demo. 30 righe → UI con upload, slider, output.
  2. Streamlit — Python data-app stile.
  3. Docker — qualsiasi cosa esegui in container (Next.js, FastAPI, ComfyUI, ecc.).

Spec hardware free tier:

  • CPU: 2 vCPU, 16 GB RAM, gratis a vita. Sleep dopo 48 h di inattività (si risveglia al primo accesso).
  • ZeroGPU: GPU H200 on-demand, gratis con quota condivisa. Pensato per demo che girano pochi secondi/uso (es. Stable Diffusion fast).
  • Persistent storage: a pagamento (utile per Spaces con upload utenti).
  • Tier a pagamento: A10G, A100, H100 da $0.60 a $4/h.

Esempio: il “ChatGPT clone” in 10 minuti

app.py:

import gradio as gr
from huggingface_hub import InferenceClient

client = InferenceClient(model="meta-llama/Llama-3.2-3B-Instruct")

def chat(message, history):
    messages = [{"role": "user", "content": m} for m, _ in history] + \
               [{"role": "user", "content": message}]
    out = client.chat_completion(messages, max_tokens=512)
    return out.choices[0].message.content

gr.ChatInterface(chat).launch()

requirements.txt:

gradio>=4.0
huggingface_hub>=0.20

README.md frontmatter:

---
title: My Chatbot
sdk: gradio
sdk_version: 4.44.0
app_file: app.py
---

git push. 60 secondi. Hai un endpoint pubblico. Zero infra.

Pattern d’uso 2026

  • Demo di paper accademici (link nel paper → Space).
  • Tool comunitari (es. text-to-3D, image upscaler).
  • Leaderboard interattive (Open LLM Leaderboard è uno Space).
  • Mini-app aziendali interne (Space privato + SSO).

La triade in pratica

Lo workflow tipico di un ricercatore:

  1. Pretraining su un Dataset (fineweb-edu).
  2. Upload del modello sull’Hub, model card scritta.
  3. Fine-tune su un secondo Dataset (ultrachat).
  4. Upload del fine-tune (nuovo repo).
  5. Build di uno Space con Gradio che mostra il modello a tutti.

Tutto via huggingface-cli login + git push. Totale costo infrastrutturale per la pubblicazione: 0 €.

Cosa NON è

  • Non è un LMS — non insegna, anche se ha corsi gratuiti (huggingface.co/learn).
  • Non è un cloud GPU general purpose — Spaces è per demo, non per training a 100 GPU (per quello esistono provider dedicati).
  • Non è production serving su scala — Inference Endpoints risolve molto, ma per traffico enterprise serio in genere si va su Bedrock, Vertex, vLLM self-hosted.

Glossario lampo

  • safetensors — formato pesi: header JSON + tensori binari + checksum. Memory-mapped, deterministico, sicuro.
  • ZeroGPU — sistema HF che alloca on-demand una H200 per pochi secondi a chi visita uno Space, condividendo le GPU fra centinaia di Space.
  • Pipeline tag — categoria task standardizzata (text-generation, image-classification, automatic-speech-recognition…) che HF usa per filtri e auto-routing.
  • Dataset viewer — front-end web che renderizza un sample del dataset (richiede formato compatibile, Parquet preferito).

Take-away

Hub, Datasets, Spaces sono le tre stanze della stessa casa. Hub conserva l’ingrediente, Datasets la ricetta, Spaces serve il piatto al tavolo. Imparare a usarle in cascata vale molto più di “imparare un framework”: è il workflow canonico dell’AI open nel 2026.

➡️ Prossima puntata: la famiglia open — Llama, Mistral, Qwen, DeepSeek, Gemma, Kimi.