Programma Lezione 204 di 250 · Il fine-tuning, a livello concettuale
Il fine-tuning, a livello concettuale

Occupazione di memoria: 4 bit contro 16 bit

Ecco l'aritmetica che decide se un modello ci sta almeno sul tuo hardware, e perché i modelli "quantizzati" sono ovunque. I pesi di un modello sono solo numeri, e ogni numero occupa un certo numero di byte a seconda della precisione. L'occupazione è semplice:

bytes = params * bits_per_param / 8
# (8 bits per byte)

L'addestramento e l'inferenza a piena precisione usano spesso float a 16 bit (2 byte ciascuno). Per far girare un modello su un portatile o un telefono lo quantizzi: salvi ogni peso in meno bit. La quantizzazione a 4 bit usa un quarto dei byte, perché 4 bit sono un quarto di 16 bit. Stesso numero di parametri, un quarto della memoria.

Facciamo i conti su un modello da 7 miliardi di parametri:

16-bit: 7e9 * 16 / 8 = 1.4e10 bytes  ~= 13.04 GiB
 4-bit: 7e9 *  4 / 8 = 3.5e9  bytes  ~=  3.26 GiB   (exactly 1/4)

È la differenza tra un modello che ha bisogno di una GPU grande e uno che gira su un portatile. È esattamente il motivo per cui un assistente sul dispositivo (come quello che alimenta il tutor IA di questo corso) usa un modello a 4 bit: il costo in qualità è piccolo, il guadagno in memoria e banda è enorme. È anche il motivo per cui il fine-tuning efficiente nei parametri (LoRA) è interessante, salvi e distribuisci solo pochi piccoli pesi di adattatori sopra una base congelata, magari quantizzata.

Che cosa lascia fuori la formula semplice. Conta solo i pesi, quindi considerala un minimo. I formati a 4 bit veri salvano anche una scala per ogni piccolo gruppo di pesi, e questo li porta a circa 4.5-5 bit per peso (un modello da 7B è più vicino a 4 GiB che a 3.26). Far girare il modello richiede spazio per la cache KV, che cresce con la lunghezza del contesto. E l'addestramento richiede molto più dei pesi: il fine-tuning completo con l'ottimizzatore Adam tiene i gradienti e due stati dell'ottimizzatore per peso, circa 16 byte per parametro in precisione mista, quindi circa 100 GiB per un modello da 7B prima delle attivazioni. Quel divario è il vero motivo per cui esistono LoRA e il fine-tuning quantizzato.

Riportiamo l'occupazione in GiB (gibibyte), dividendo i byte per 1024 ** 3. Tienila come float esatto, non arrotondare, così le relazioni qui sotto valgono con precisione.

Costruisci due funzioni.

  • model_memory(params, bits_per_param) -> l'occupazione in GiB come float: params * bits_per_param / 8 / (1024 ** 3).
  • quantization_savings(params, from_bits, to_bits) -> {"before_gb", "after_gb", "ratio"}, dove before_gb e after_gb sono le due occupazioni e ratio è from_bits / to_bits (quante volte più piccolo è il modello quantizzato).

La matematica è vera e si può correggere; l'addestramento su GPU che rende possibile non è qualcosa che questa sandbox può eseguire. Premi Run per stampare l'occupazione di un modello da 7B a qualche precisione.

Tocca a te

Scrivi model_memory(params, bits_per_param) che restituisce l'occupazione in GiB come float (params * bits_per_param / 8 / (1024 ** 3)), e quantization_savings(params, from_bits, to_bits) che restituisce {"before_gb", "after_gb", "ratio"} dove le due occupazioni vengono da model_memory e ratio è from_bits / to_bits. Non arrotondare; tieni float esatti così 4 bit viene esattamente un quarto di 16 bit.

Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione

Questo esercizio si apre presto

Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.