पाठ्यक्रम 250 में से पाठ 204 · Fine-tuning, अवधारणा के स्तर पर
Fine-tuning, अवधारणा के स्तर पर

मेमोरी footprint: 4-bit बनाम 16-bit

यह वह गणित है जो तय करता है कि कोई मॉडल आपके hardware में आता भी है या नहीं, और "quantized" मॉडल हर जगह क्यों हैं। मॉडल के weights बस संख्याएँ हैं, और हर संख्या अपनी सटीकता के हिसाब से कुछ bytes लेती है। footprint सादा है:

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

Training और पूरी सटीकता वाला inference अक्सर 16-bit floats (हर एक 2 bytes) इस्तेमाल करते हैं। किसी मॉडल को लैपटॉप या फ़ोन पर चलाने के लिए आप उसे quantize करते हैं: हर weight को कम bits में रखते हैं। 4-bit quantization bytes का एक चौथाई इस्तेमाल करता है, क्योंकि 4 bits 16 bits का एक चौथाई है। वही parameter गिनती, मेमोरी का एक चौथाई।

एक 7-अरब-parameter मॉडल का हिसाब लगाएँ:

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)

यही अंतर है उस मॉडल के बीच जिसे बड़ा GPU चाहिए और उस मॉडल के बीच जो लैपटॉप पर चलता है। ठीक इसी वजह से एक on-device सहायक (जैसे इस कोर्स के AI ट्यूटर को चलाने वाला) 4-bit मॉडल के साथ आता है: गुणवत्ता की क़ीमत छोटी है, मेमोरी और bandwidth की जीत बहुत बड़ी। इसीलिए parameter-efficient fine-tuning (LoRA) आकर्षक है, आप जमे हुए, शायद quantized, base के ऊपर बस कुछ छोटे adapter weights रखते और भेजते हैं।

सादा सूत्र क्या छोड़ देता है। यह सिर्फ़ weights गिनता है, इसलिए इसे न्यूनतम मानें। असली 4-bit फ़ॉर्मैट weights के हर छोटे समूह के लिए एक scale भी रखते हैं, जो उन्हें लगभग 4.5 से 5 bits प्रति weight तक ले आता है (7B मॉडल 3.26 के बजाय 4 GiB के ज़्यादा पास है)। मॉडल चलाने के लिए KV cache की जगह चाहिए, जो context की लंबाई के साथ बढ़ती है। और training को weights से कहीं ज़्यादा चाहिए: Adam optimiser के साथ full fine-tuning हर weight के लिए gradients और दो optimiser states रखता है, mixed precision में लगभग 16 bytes प्रति parameter, यानी activations से पहले 7B मॉडल के लिए मोटे तौर पर 100 GiB। यही अंतर असली वजह है कि LoRA और quantized fine-tuning मौजूद हैं।

हम footprint GiB (gibibytes) में बताते हैं, bytes को 1024 ** 3 से भाग देकर। इसे सटीक float रखें, गोल न करें, ताकि नीचे के रिश्ते ठीक-ठीक बने रहें।

दो फ़ंक्शन बनाएँ।

  • model_memory(params, bits_per_param) -> GiB में float के रूप में footprint: params * bits_per_param / 8 / (1024 ** 3)।
  • quantization_savings(params, from_bits, to_bits) -> {"before_gb", "after_gb", "ratio"}, जहाँ before_gb और after_gb दोनों footprints हैं और ratio है from_bits / to_bits (quantized मॉडल कितने गुना छोटा है)।

गणित असली और ग्रेड करने लायक है; जिस GPU training को यह संभव बनाता है वह यह sandbox नहीं चला सकता। कुछ सटीकताओं पर 7B मॉडल का footprint print करने के लिए Run दबाएँ।

आपकी बारी

model_memory(params, bits_per_param) लिखें जो GiB में float के रूप में footprint लौटाए (params * bits_per_param / 8 / (1024 ** 3)), और quantization_savings(params, from_bits, to_bits) जो {"before_gb", "after_gb", "ratio"} लौटाए जहाँ दोनों footprints model_memory से आते हैं और ratio है from_bits / to_bits। गोल न करें; सटीक floats रखें ताकि 4-bit ठीक 16-bit का एक चौथाई निकले।

इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें

यह अभ्यास जल्द खुलेगा

इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।