LLM क्वांटाइज़ेशन के लिए एक विज़ुअल गाइड

• बड़े भाषा मॉडल (LLM) सामान्य हार्डवेयर पर चलाने के लिए बहुत बड़े होते हैं, और इनमें आमतौर पर अरबों parameters होते हैं, इसलिए इन्हें बहुत अधिक VRAM वाले GPU की ज़रूरत होती है
• इसलिए बेहतर training, adapters आदि के माध्यम से इन मॉडलों को छोटा बनाने पर शोध लगातार बढ़ रहा है, और इस क्षेत्र की प्रमुख तकनीकों में से एक है quantization

Part 1: बड़े भाषा मॉडल की "समस्या"

• LLM (Large Language Model) का नाम इसमें शामिल parameters की संख्या के आधार पर रखा गया है
• ऐसे मॉडलों में आमतौर पर अरबों parameters (मुख्यतः weights) शामिल होते हैं, जिनकी storage cost काफी अधिक हो सकती है
• inference के दौरान activations input और weights के गुणन से बनते हैं, और ये भी काफ़ी बड़े हो सकते हैं
• इसलिए लक्ष्य यह होता है कि दिए गए values को store करने के लिए आवश्यक space को कम से कम रखा जाए, और साथ ही अरबों values को यथासंभव कुशलता से represent किया जाए

संख्यात्मक मानों को represent करने के तरीके

• दिए गए values को अक्सर floating-point numbers (वास्तविक संख्याएँ) के रूप में represent किया जाता है
• इन values को "bits" से represent किया जाता है, और IEEE-754 standard बताता है कि bits किस तरह sign, exponent, और fraction में से किसी एक की भूमिका निभाकर value को represent करते हैं
• किसी value को represent करने के लिए जितने अधिक bits उपयोग किए जाते हैं, सामान्यतः precision उतनी अधिक होती है
• और जितने अधिक bits उपलब्ध हों, represent किए जा सकने वाले values की range उतनी बड़ी होती है

memory constraints

• मान लें कि किसी मॉडल में 70 अरब parameters हैं, तो FP32 (full-precision) का उपयोग करने पर केवल मॉडल load करने के लिए ही 280GB memory चाहिए होगी
• इसलिए मॉडल के parameters को represent करने वाले bits की संख्या कम करना बहुत महत्वपूर्ण है, लेकिन precision घटने पर मॉडल की accuracy भी सामान्यतः कम हो जाती है
• उद्देश्य यह है कि accuracy बनाए रखते हुए values को represent करने के लिए आवश्यक bits की संख्या कम की जाए, और यही वह जगह है जहाँ quantization काम आता है

Part 2: quantization का परिचय

• quantization का लक्ष्य मॉडल parameters की precision को high bit-width (जैसे 32-bit floating point) से low bit-width (जैसे 8-bit integer) तक घटाना है
• हर बार bits घटाने पर मूल parameters को low-bit representation में "compress" करने के लिए एक mapping की जाती है

सामान्य data types

FP16

• FP32 से FP16 (half precision) पर जाने पर FP16 जिन values को ले सकता है उनकी range, FP32 की तुलना में काफी कम हो जाती है

BF16

• FP32 जैसी value range पाने के लिए bfloat16 पेश किया गया, जो एक तरह का "truncated FP32" है
• BF16, FP16 जितने ही bits का उपयोग करता है, लेकिन values की अधिक विस्तृत range रख सकता है, और deep learning applications में अक्सर उपयोग होता है

INT8

• bits की संख्या और घटाने पर representation floating point के बजाय integer-based representation के अधिक करीब पहुँच जाता है

symmetric quantization

• मूल floating-point values की range को quantized space में 0 के आसपास symmetric range पर map किया जाता है
• floating-point space में 0 का quantized value, quantized space में ठीक 0 ही होता है

asymmetric quantization

• symmetric quantization के विपरीत, यह 0 के आसपास symmetric नहीं होता
• floating-point range के minimum value (β) और maximum value (α) को quantized range के minimum और maximum पर map किया जाता है
• इसे zero-point quantization कहा जाने वाला एक तरीका भी माना जाता है

range mapping और clipping

• यदि vector की पूरी range को map किया जाए, तो outliers की वजह से सभी छोटे values एक ही low-bit representation में map हो सकते हैं, जिससे उनका भेद समाप्त हो जाता है
• इसके बजाय कुछ values को clip करने का विकल्प चुना जा सकता है
• clipping का अर्थ है कि अलग dynamic range सेट किया जाए ताकि सभी outliers एक ही value ले लें
• इससे non-outlier values की quantization error बहुत कम हो जाती है, लेकिन outliers की quantization error बढ़ जाती है

calibration

weights (और bias)

• weights और bias को मॉडल चलाने से पहले ज्ञात static values माना जा सकता है
• bias, weights की तुलना में बहुत कम होते हैं, इसलिए इन्हें अधिक precision (जैसे INT16) में रखा जाता है, और quantization का मुख्य फ़ोकस weights पर होता है
• static और ज्ञात weights के लिए calibration तकनीकों में input range के percentile को manually चुनना, मूल और quantized weights के बीच mean squared error (MSE) को optimize करना, या मूल और quantized values के बीच entropy (KL divergence) को minimize करना शामिल है

activations

• inputs पूरे LLM में लगातार update होते रहते हैं, और इन्हें सामान्यतः "activations" कहा जाता है
• ये values हर बार बदलती हैं जब inference के दौरान अलग input data मॉडल में दिया जाता है, इसलिए इन्हें सटीक रूप से quantize करना कठिन होता है
• ये values हर hidden layer के बाद update होती हैं, इसलिए inference के दौरान ये क्या होंगी, यह तभी पता चलता है जब input data मॉडल से होकर गुजरता है

Part 3: post-training quantization (PTQ)

dynamic quantization

• data के hidden layers से गुजरने के बाद activations एकत्र किए जाते हैं
• इस activation distribution का उपयोग output को quantize करने के लिए आवश्यक zero-point (z) और scale factor (s) की गणना करने में किया जाता है
• data हर नई layer से गुजरता है तो यह प्रक्रिया दोहराई जाती है। इसलिए हर layer के अपने अलग z और s values होते हैं, और उसकी quantization scheme भी अलग होती है

static quantization

• inference के दौरान नहीं, बल्कि पहले से zero-point (z) और scale factor (s) की गणना की जाती है
• इन values को खोजने के लिए calibration dataset का उपयोग किया जाता है, जिसे मॉडल में देकर संभावित distributions एकत्र किए जाते हैं
• वास्तविक inference करते समय s और z values दोबारा calculate नहीं किए जाते, बल्कि सभी activations के लिए globally उपयोग करके quantization किया जाता है
• सामान्यतः dynamic quantization थोड़ा अधिक accurate होता है क्योंकि वह हर hidden layer के लिए s और z values calculate करता है, लेकिन इससे compute time बढ़ सकता है
• दूसरी ओर, static quantization कम accurate होता है, लेकिन पहले से s और z values ज्ञात होने के कारण तेज़ होता है

4-bit quantization का क्षेत्र

• 8-bit से नीचे जाना कठिन साबित हुआ है क्योंकि हर bit कम होने पर quantization error बढ़ती जाती है
• HuggingFace पर आम तौर पर साझा किए जाने वाले दो तरीकों, GPTQ और GGUF, की पड़ताल

GPTQ

• 4-bit quantization के लिए वास्तव में सबसे प्रसिद्ध तरीकों में से एक
• यह asymmetric quantization का उपयोग करता है और layer-by-layer किया जाता है, जहाँ हर layer को स्वतंत्र रूप से process करके अगली layer पर बढ़ा जाता है
• layer-wise quantization प्रक्रिया के दौरान पहले layer के weights को inverse Hessian में बदला जाता है, जो model loss function का second derivative है और यह बताता है कि हर weight में बदलाव के प्रति model output कितना sensitive है
• सरल शब्दों में, यह layer में हर weight की (inverse) importance दिखाता है
• Hessian matrix में जिन weights के values छोटे होते हैं, वे अधिक महत्वपूर्ण होते हैं क्योंकि ऐसे weights में छोटा बदलाव भी model performance में बड़ा परिवर्तन ला सकता है

GGUF

• GPTQ पूरे LLM को GPU पर चलाने के लिए एक अच्छा quantization तरीका है, लेकिन हर किसी के पास हमेशा इतनी capacity नहीं होती
• इसके बजाय LLM की सभी layers को CPU पर offload करने के लिए GGUF का उपयोग किया जा सकता है
• यह पर्याप्त VRAM न होने पर CPU और GPU दोनों का उपयोग करना संभव बनाता है

Part 4: quantization aware training (QAT)

• Part 3 में हमने training के बाद मॉडल को quantize करने के तरीके देखे, लेकिन उनकी कमी यह है कि यह quantization वास्तविक training process को ध्यान में नहीं रखती
• यही वह जगह है जहाँ quantization aware training (QAT) आता है। PTQ के विपरीत, QAT का लक्ष्य training के दौरान ही quantization procedure को सीखना है
• QAT, PTQ की तुलना में अधिक accurate होता है क्योंकि training के दौरान quantization को पहले से ध्यान में रखा गया होता है

1-bit LLM का युग: BitNet

• BitNet मॉडल के weights को एक single 1-bit, यानी -1 या 1, के रूप में represent करता है
• यह transformer architecture में quantization process को सीधे inject करके किया जाता है
• transformer architecture अधिकांश LLM का आधार है और इसमें linear layers शामिल करने वाली computations होती हैं
• BitNet इन linear layers को BitLinear नाम की संरचना से replace करता है

weight quantization

• training के दौरान weights को INT8 में store किया जाता है और फिर एक मूल रणनीति, sign function, का उपयोग करके 1-bit में quantize किया जाता है
• मूल रूप से, weight distribution को 0 के आसपास shift किया जाता है, फिर 0 के बाईं ओर की हर चीज़ को -1 और दाईं ओर की हर चीज़ को 1 दिया जाता है

activation quantization

• activations को quantize करने के लिए BitLinear, activations को FP16 से INT8 में बदलने हेतु absmax quantization का उपयोग करता है, क्योंकि matrix multiplication (×) के लिए अधिक precision की आवश्यकता होती है

dequantization

• α (activation के absolute values में सबसे बड़ा value) और β (weights का mean absolute value) को track किया गया, और ये values बाद में activations को FP16 में dequantize करने में मदद करती हैं
• output activations को {α, γ} के साथ rescale किया जाता है ताकि उन्हें मूल precision में dequantize किया जा सके

सभी बड़े भाषा मॉडल 1.58-bit हैं

• BitNet 1.58b को पहले बताए गए scaling issues में सुधार के लिए पेश किया गया
• इस नए तरीके में मॉडल का हर single weight अब सिर्फ -1 या 1 ही नहीं, बल्कि 0 भी ले सकता है, इसलिए यह ternary बन जाता है
  • रोचक बात यह है कि सिर्फ 0 जोड़ने से भी BitNet में बड़ा सुधार होता है और computation speed काफी बढ़ जाती है

0 की शक्ति

• 0 जोड़ना इतना बड़ा सुधार क्यों है? यह पूरी तरह matrix multiplication से जुड़ा है
• यदि आपके पास 1.58-bit quantized weights हैं, तो इससे न केवल computation speed काफी बढ़ सकती है क्योंकि केवल multiplication करना होता है, बल्कि feature filtering भी संभव होती है

quantization

• weight quantization करने के लिए BitNet 1.58b, absmax quantization के एक variation absmean quantization का उपयोग करता है, जिसे हमने पहले देखा था
• यह simply weight distribution को compress करता है और values को quantize करने के लिए absolute mean (α) का उपयोग करता है, और फिर इन्हें -1, 0, या 1 पर round किया जाता है
• BitNet की तुलना में activation quantization लगभग वैसी ही रहती है, बस एक अंतर के साथ। activations को [0, 2ᵇ⁻¹] range में adjust करने के बजाय अब absmax quantization का उपयोग करके उन्हें [-2ᵇ⁻¹, 2ᵇ⁻¹] में adjust किया जाता है
• 1.58-bit quantization के लिए (मुख्यतः) दो tricks की आवश्यकता थी:
  • ternary representation [-1, 0, 1] बनाने के लिए 0 जोड़ना
  • weights के लिए absmean quantization

• "13B BitNet b1.58 latency, memory usage और energy consumption के लिहाज़ से 3B FP16 LLM से अधिक efficient है"

• इसलिए केवल computationally efficient 1.58-bit quantization के कारण lightweight models प्राप्त किए जा सकते हैं