Da zero assoluto · per ingegneri di sistema

Smettere di usare i modelli.
Cominciare a capirli.

Nessun prerequisito matematico. Ogni concetto astratto finisce in un print(): nome del tensore, forma, tipo, riga di codice. Se non puoi stamparlo, non è ancora tuo.

Questo corso è scritto per chi sa mandare in produzione un motore di inferenza, sa dove va la memoria di un nodo e perché uno storage rallenta — e per cui quello che c'è dentro il modello è ancora una scatola chiusa: pesi mai aperti, addestramenti che o funzionano o no senza che si sappia dire perché.

Apre la scatola. Parte dal significato di «numero moltiplicato per una matrice» e arriva a diagnosticare con metodo un caso reale: un adattatore LoRA su un modello denso da 27B che rende meno del previsto, senza che nessuno sappia se la colpa sia dei dati, degli iperparametri, del template, della valutazione o di un disallineamento fra addestramento e inferenza.

Quel caso attraversa tutto il corso ed è l'ultimo modulo.

Adattarlo
al tuo caso

Hardware, modello di riferimento e caso di studio sono dichiarati in assets/profilo.js. Cambiando quei valori si aggiorna l'intestazione delle pagine, e i lab che accettano parametri — come il calcolatore di memoria di M06 — si eseguono sui tuoi numeri:

python3 corso/labs/lab_06_1_memoria.py --params 8e9 --gpus 4 --hbm 80

Il campo che conta più di tutti è regime: GPU singola, più schede in un nodo, memoria unificata, cluster, noleggio. Non cambia i numeri — cambia quale vincolo morde, ed è il tema di M18b.

Quello che il profilo NON fa, ed è bene saperlo prima: non riscrive i numeri già stampati nelle pagine. I 54 GB, i 432 GB, le forme dei tensori e i conteggi LoRA restano quelli del profilo di riferimento — un denso da 27B su due schede da 141 GB. Vanno letti come un caso svolto: il metodo è tuo, i numeri sono suoi.

Quello che invece fa, da M06 in poi: accanto a ogni tabella di memoria compare il tuo ricalcolo, con le stesse formule del lab. Che le due strade coincidano non è un atto di fede — lo verifica tools/parity_conti.py a ogni rilascio, con uguaglianza esatta.

Prima di tutto il resto

Con N schede da M GB non hai N×M GB di memoria. Hai N volte M GB, separate.

Un'interconnessione veloce rende rapido lo scambio di dati fra le schede. Non le fonde in un unico spazio di indirizzamento. Un modello che non sta in una scheda non «ci sta comunque»: va spezzato, e come lo spezzi cambia completamente il conto.

È l'errore numero uno di chi arriva dall'infrastruttura, dove sommare le risorse di un pool è il gesto naturale. Qui non lo è, e nessun calcolo di capienza funziona finché quel riflesso non è disinnescato. I numeri arrivano in M06.

Con una eccezione, e riguarda alcuni di voi. Sulle macchine a memoria unificata — DGX Spark, Grace — il pool è davvero uno solo, condiviso fra CPU e acceleratore. Lì la somma non è sbagliata: è sbagliata la domanda. La capienza smette di essere il vincolo e comincia a esserlo la banda. È uno dei quattro regimi di M18b.

Cosa saprai fare

Cinque capacità verificabili. Sono il metro di misura del corso, non slogan: ognuna si controlla facendoti fare una cosa, non facendoti dire che l'hai capita.

Aprire un modello e leggerne i pesi, tensore per tensore: nome, forma, tipo numerico, funzione. Contare i parametri a mano e ritrovare il numero dichiarato.
Calcolare prima di lanciare se un addestramento entra nella memoria di una GPU — e, quando non entra, sapere quale termine del conto avevi sbagliato.
Scegliere il metodo fra full fine-tuning, LoRA, QLoRA, DPO, RL, distillazione. Soprattutto: saper dire quando ciascuno è la scelta sbagliata, e perché.
Diagnosticare un addestramento fallito con metodo: ipotesi in ordine di costo, un esperimento che ne falsifica una sola alla volta, criterio di decisione scritto prima di eseguire.
Addestrare un modello piccolo da zero, scritto riga per riga da te, e vedere la loss scendere sapendo esattamente perché scende.

Due percorsi

Il percorso completo, a 4 ore a settimana, è quasi un anno. È dichiarato onestamente, ma per molti significa non cominciare affatto — e chi deve solo capire perché il suo fine-tuning non funziona non ha bisogno di scrivere un transformer da zero.

I moduli del percorso ridotto sono marcati NUCLEO nella mappa qui sotto. Le due cifre sono calcolate dall'indice dei moduli, non scritte a mano: se una durata cambia, cambiano con lei.

Cosa perdi
col percorso
ridotto

Non è una versione «leggera» dello stesso corso: è un corso diverso. Salti la costruzione del modello — architettura, autograd, optimizer, i regimi di addestramento — e tieni solo la catena che porta a una diagnosi: pesi, memoria, dati, valutazione, LoRA, riproducibilità, parity, protocollo.

La conseguenza pratica: potrai escludere ipotesi e leggere quello che gli altri scrivono, ma quando una diagnosi richiederà di modificare il modello o di capire perché un optimizer si comporta così, ti mancheranno gli strumenti. A quel punto i moduli saltati sono ancora lì.

La mappa

L'offset è il tempo cumulato dall'inizio, la durata è il lavoro stimato per quel modulo — lettura, esercizi e lab compresi. Sono numeri veri, servono per pianificare.

Dove gira cosa

Macchina	Risorse	Serve da
CPU Portatile	`torch`, `numpy`, `safetensors`. Nessuna GPU	M01 → M06. Tutta la Parte I e II.
GPU Nodo di addestramento	le GPU dichiarate nel profilo, NVLink	Da M07. Quando il vincolo diventa la memoria.
	CPU molti core, RAM abbondante, NVMe locale	M06 per l'offload, M18 per il parallelismo.

Perché si parte
senza GPU

Stessa ragione per cui non si fa il debug di un Dockerfile direttamente in produzione. I concetti dei primi moduli si vedono meglio su tensori da tre elementi, che puoi stampare per intero, che su matrici 4096×4096 che non stanno in uno schermo.

La GPU serve quando il vincolo diventa la memoria — cioè da M06 in poi. Prima è solo un modo costoso di fare le stesse moltiplicazioni.

Onestà sul risultato

Alla fine di questo percorso sarai autonomo nel riprodurre e adattare metodi noti usando le primitive dei framework, su un singolo nodo: prevedere la memoria prima di lanciare, progettare una valutazione che regge statisticamente, diagnosticare un fallimento per esclusione ordinata invece che per tentativi, leggere un paper di metodo e capirlo.

Quello che questo corso non ti dà, detto senza addolcirlo:

Fuori portata	Perché
Diventare un ricercatore	È un altro mestiere e richiede altro. Nessun corso lo sostituisce.
«Implementare un paper qualsiasi»	Promessa illimitata: un paper può richiedere matematica, kernel CUDA, dati o scala che qui non compaiono mai.
L'intuizione del pretraining vero	Si forma su addestramenti da settimane su migliaia di GPU. Le formule le capirai, il giudizio no.
I guasti da scala e durata	Divergenze dopo giorni, picchi di loss legati a un singolo shard, guasti hardware a metà run, recupero da checkpoint corrotto. Servono run lunghi e veri.
Full fine-tuning di modelli grandi in sola memoria GPU	Con offload su RAM abbondante e NVMe la soglia si sposta, a costo di lentezza spesso inaccettabile. Non è un muro assoluto — ma non è nemmeno gratis, e in M06 lo calcolerai.