Programma Les 204 van 250 · Fine-Tuning, Conceptueel
Fine-Tuning, Conceptueel

Geheugengebruik: 4-bit vs 16-bit

Hier is de rekenkundige berekening die bepaalt of een model überhaupt op je hardware past, en waarom "gekwantiseerde" modellen overal zijn. De weights van een model zijn gewoon getallen, en elk getal neemt wat bytes in afhankelijk van de precisie. De footprint is simpel:

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

Training en full-precision inference gebruiken vaak 16-bit floats (2 bytes elk). Om een model op een laptop of telefoon te draaien, quantize je het: sla elke weight op in minder bits. 4-bit quantization gebruikt een kwart van de bytes, omdat 4 bits een kwart is van 16 bits. Dezelfde parameter count, een kwart van het geheugen.

Werk aan een model met 7 miljard parameters:

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)

Dat is het verschil tussen een model dat een grote GPU nodig heeft en een model dat op een laptop draait. Dat is precies waarom een on-device assistent (zoals de AI-tutor van deze cursus) een 4-bit model gebruikt: de kwaliteitskosten zijn klein, de winst in geheugen en bandbreedte is enorm. Dit is ook waarom parameter-efficient fine-tuning (LoRA) aantrekkelijk is, je slaat en verzendt alleen een paar kleine adapter weights bovenop een bevroren, mogelijk gequantiseerde, basis.

Wat de simpele formule weglaat. Het telt alleen de gewichten, dus zie het als een ondergrens. Echte 4-bit formaten slaan ook een schaal op voor elke kleine groep gewichten, wat ze naar ongeveer 4,5 tot 5 bits per gewicht brengt (een 7B model is dichter bij 4 GiB dan 3,26). Het draaien van het model heeft ruimte nodig voor de KV cache, die groeit met de contextlengte. En training heeft veel meer nodig dan de gewichten: volledige fine-tuning met de Adam optimiser houdt gradiënten en twee optimiser states per gewicht vast, ongeveer 16 bytes per parameter in mixed precision, dus ruwweg 100 GiB voor een 7B model voor de activaties. Dat gat is de echte reden waarom LoRA en gequantiseerde fine-tuning bestaan.

We rapporteren de footprint in GiB (gibibytes), door bytes te delen door 1024 ** 3. Houd het als een exacte float, rond niet af, zodat de relaties hieronder precies kloppen.

Bouw twee functies.

  • model_memory(params, bits_per_param) -> de voetafdruk in GiB als float: params * bits_per_param / 8 / (1024 ** 3).
  • quantization_savings(params, from_bits, to_bits) -> {"before_gb", "after_gb", "ratio"}, waar before_gb en after_gb de twee voetafdrukken zijn en ratio is from_bits / to_bits (hoeveel keer kleiner het gekwantiseerde model is).

De wiskunde is echt en beoordeelbaar; de GPU training die het mogelijk maakt is niet iets wat deze sandbox kan draaien. Druk Run in om de footprint van een 7B model bij een paar precisies te printen.

Jij bent aan de beurt

Schrijf model_memory(params, bits_per_param) die de footprint in GiB als een float teruggeeft (params * bits_per_param / 8 / (1024 ** 3)), en quantization_savings(params, from_bits, to_bits) die {"before_gb", "after_gb", "ratio"} teruggeeft waar de twee footprints komen uit model_memory en ratio is from_bits / to_bits. Rond niet af; houd exacte floats zodat 4-bit precies een kwart van 16-bit oplevert.

Een probleem ontdekt in deze les? Meld het · Vraag naar deze les

Deze oefening opent binnenkort

Maak de les ervoor af voordat deze wordt ontgrendeld. De hele cursus is gratis, geen account nodig, en je kunt deze les nu lezen.