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"}, dovebefore_gbeafter_gbsono le due occupazioni eratioè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.
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.
Questo browser blocca i cookie per learn.floati.life, quindi le lezioni che hai finito qui non si possono aprire in ordine. Consenti i cookie per questo sito e ricarica.