Kurrikulum Leson 204 van 250 · Fyn-afstemming, Konsepueel
Fyn-afstemming, Konsepueel

Geheuevoetspoor: 4-bit teenoor 16-bit

Hier is die rekenmetriek wat besluit of 'n model selfs op jou hardeware pas, en waarom "quantized" modelle oral is. 'n Model se weights is net getalle, en elke getal neem 'n paar bytes afhangende van sy precision. Die footprint is eenvoudig:

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

Opvoering en vol-presisie inferens gebruik dikwels 16-bit floats (2 bytes elk). Om 'n model op 'n skootrekenaar of foon te hardloop, moet jy dit quantize: stoor elke gewig in minder bits. 4-bit kwantiseringing gebruik 'n kwart van die bytes, omdat 4 bits 'n kwart van 16 bits is. Dieselfde parameter-telling, een kwart van die geheue.

Werk aan 'n 7-miljoen-parameter model:

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)

Dit is die verskil tussen 'n model wat 'n groot GPU nodig het en een wat op 'n skootrekenaar hardloop. Dit is presies waarom 'n on-device assistant (soos die een wat hierdie kursus se AI tutor aandryf) 'n 4-bit model verskik: die kwaliteitverlies is klein, maar die wins in geheue en bandbreedte is groot. Dit is ook waarom parameter-efficient fine-tuning (LoRA) aantreklik is, jy stoor en verskik net 'n paar klein adapter weights bo-op 'n bevrore, moontlik gekwantiseerde basis.

Wat die eenvoudige formule uelaat. Dit tel net die gewigte, so behandel dit as 'n vloer. Ware 4-bit formate stoor ook 'n skaal vir elke klein groep gewigte, wat hulle tot ongeveer 4.5 tot 5 bits per gewig bring ('n 7B model is nader aan 4 GiB as 3.26). Om die model te hardloop, het jy plek nodig vir die KV cache, wat groei met die kontekslengte. En training het veel meer nodig as die gewigte: volledige fine-tuning met die Adam optimiser hou gradiënte en twee optimiser states per gewig, ongeveer 16 bytes per parameter in mixed precision, so ongeveer 100 GiB vir 'n 7B model voor aktiverings. Daardie gaping is die ware rede waarom LoRA en gekwantiseerde fine-tuning bestaan.

Ons rapporteer die voetspoor in GiB (gibibytes), deur bytes deur 1024 ** 3 te deel. Hou dit as 'n presiese float, moenie afgrond nie, sodat die verhoudings hieronder presies geld.

Boue twee funksies.

  • model_memory(params, bits_per_param) -> die voetspoor in GiB as 'n 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 die twee voetspore is en ratio is from_bits / to_bits (hoeveel keer kleiner die gekwantiseerde model is).

Die wiskunde is werklik en kan gegradeer word; die GPU-opleiding wat dit moontlik maak is nie iets wat hierdie sandbox kan hardloop nie. Druk Run om die voetspoor van 'n 7B model by 'n paar presisies te druk.

Jou beurt

Skryf model_memory(params, bits_per_param) wat die footprint in GiB as 'n float (params * bits_per_param / 8 / (1024 ** 3)) teruggee, en quantization_savings(params, from_bits, to_bits) wat {"before_gb", "after_gb", "ratio"} teruggee waar die twee footprints van model_memory kom en ratio is from_bits / to_bits. Moenie afrond nie; hou presiese floats sodat 4-bit presies een kwart van 16-bit uitkom.

Sien jy 'n probleem in hierdie les? Rapporteer dit · Vra oor hierdie les

Hierdie oefening open binnekort

Voltooi die lesie voor dit en hierdie een sal ontvanklik wees. Die hele kursus is gratis, geen rekening nodig nie, en jy kan hierdie les nou lees.