एक weight एक floating-point संख्या है। बस इतना ही। एक नेटवर्क में दो neurons के बीच का प्रत्येक connection इन संख्याओं में से एक रखता है, और एक आधुनिक बड़े भाषा मॉडल के पास उनमें से अरबों होते हैं — विशाल matrices में व्यवस्थित, प्रति layer एक। प्रशिक्षण शुरू होने से पहले, ये matrices उन मूल्यों से भर जाती हैं जो अनिवार्य रूप से random दिखते हैं (initialization पर एक क्षण में अधिक)। फिर नेटवर्क डेटा देखता है, एक loss function के माध्यम से गणना करता है कि उसकी भविष्यवाणियाँ कितनी गलत हैं, और backpropagation उस त्रुटि के gradient को हर layer के माध्यम से पीछे की ओर प्रवाहित करता है, हर weight को उस दिशा में थोड़ी मात्रा में धकेलता है जो भविष्यवाणी को कम गलत बनाती। इसे टेराबाइट टेक्स्ट पर कुछ अरब बार दोहराएँ और आपको एक मॉडल मिलता है जो कविता लिख सकता है, quantum यांत्रिकी की व्याख्या कर सकता है, या आपके कोड को debug कर सकता है। Weights वहाँ हैं जहाँ वह सारी सीखी हुई क्षमता रहती है। कोई अलग ज्ञान भंडार नहीं है, तथ्यों का कोई डेटाबेस नहीं — बस संख्याओं के matrices जो, शुद्ध सांख्यिकीय दबाव के माध्यम से, खुद को कुछ ऐसे में संगठित कर चुके हैं जो बहुत हद तक समझ की तरह दिखता है।
आप उन संख्याओं को जिस फ़ॉर्मैट में संग्रहीत करते हैं वह उससे अधिक मायने रखता है जितना आप अपेक्षा कर सकते हैं। पूर्ण-परिशुद्धता weights fp32 का उपयोग करते हैं — 32-bit floating point — जो आपको लगभग 7 दशमलव अंकों की परिशुद्धता और एक विशाल dynamic range देता है। यही वह है जो शोधकर्ताओं ने वर्षों तक उपयोग किया, और यह अभी भी संख्यात्मक स्थिरता के लिए स्वर्ण मानक है। लेकिन fp32 महंगा है: fp32 में एक 7-अरब-parameter मॉडल केवल weights के लिए 28 GB खाता है, इससे पहले कि आप optimizer states या activations के बारे में सोचें। आधी-परिशुद्धता fp16 इसे आधा कर देती है, लेकिन इसकी सीमित exponent range इसे प्रशिक्षण के दौरान overflow और underflow के लिए प्रवण बनाती है। यहाँ आता है bf16 — bfloat16 — जो fp32 की exponent range रखता है लेकिन mantissa को 16 bits तक truncate करता है। Google ने इसे विशेष रूप से डीप लर्निंग के लिए विकसित किया, और यह प्रशिक्षण के लिए वास्तविक मानक बन गया है क्योंकि fp32 की आधी मेमोरी का उपयोग करते हुए यह संख्यात्मक रूप से शायद ही कभी विस्फोट करता है। Inference के लिए, आप और आगे जा सकते हैं: int8 quantization weights को 8-bit integers (fp32 के एक चौथाई आकार) में पैक करता है आश्चर्यजनक रूप से कम गुणवत्ता हानि के साथ, और int4 — GPTQ और AWQ विधियों द्वारा अग्रणी — उसे फिर से आधा कर देता है। एक 70B मॉडल जिसे fp16 में 140 GB की आवश्यकता होगी, 4-bit परिशुद्धता पर लगभग 35 GB में फ़िट हो जाता है, यही कारण है कि quantization वह कारण है जिससे आप उपभोक्ता GPUs पर गंभीर मॉडल चला सकते हैं।
जब आप एक मॉडल डाउनलोड करते हैं, तो फ़ाइल फ़ॉर्मैट निर्धारित करता है कि उन weight matrices को disk पर कैसे serialize किया जाता है। वर्षों तक, default PyTorch का .bin फ़ॉर्मैट था, जो tensors पर लागू Python के pickle serialization के अलावा और कुछ नहीं है। यह काम करता है, लेकिन pickle की एक प्रसिद्ध सुरक्षा समस्या है: जब आप इसे load करते हैं तो एक दुर्भावनापूर्ण .bin फ़ाइल मनमाना कोड execute कर सकती है। Hugging Face ने इसे ठीक करने के लिए विशेष रूप से safetensors बनाया — यह एक सरल, memory-mapped फ़ॉर्मैट है जिसमें केवल tensor डेटा और मेटाडेटा होता है, बिना कोड execution की संभावना के। Safetensors तेज़ी से load भी होता है क्योंकि यह lazy loading और zero-copy reads का समर्थन करता है। यह Hugging Face और उससे आगे मॉडलों को वितरित करने के लिए मानक बन गया है। फिर GGUF है, जो llama.cpp और व्यापक स्थानीय-inference ecosystem द्वारा उपयोग किया जाने वाला फ़ॉर्मैट है। GGUF weights, tokenizer कॉन्फ़िगरेशन और मॉडल मेटाडेटा को एक एकल स्व-निहित फ़ाइल में बंडल करता है, अक्सर अंतर्निहित quantization के साथ। यदि आप अपने laptop या एक उपभोक्ता GPU पर स्थानीय रूप से एक मॉडल चला रहे हैं, तो आप लगभग निश्चित रूप से GGUF फ़ाइल का उपयोग कर रहे हैं। संक्षिप्त संस्करण: वितरण और fine-tuning के लिए safetensors, स्थानीय inference के लिए GGUF, और .bin केवल जब आप विरासत checkpoints का सामना करते हैं।
प्रशिक्षण शुरू होने से पहले भी, आप उन weight matrices में जो मूल्य डालते हैं वे उसके बाद होने वाली हर चीज़ को आकार देते हैं। उन्हें सभी को शून्य पर initialize करें और नेटवर्क सीख नहीं सकता — एक layer में हर neuron एक ही चीज़ की गणना करता है, इसलिए gradients समान हैं और समरूपता कभी नहीं टूटती। उन्हें बहुत बड़ा initialize करें और activations विस्फोट करते हैं; बहुत छोटा और gradients शुरुआती layers तक पहुँचने से पहले शून्य तक गायब हो जाते हैं। Xavier initialization (2010) ने sigmoid और tanh नेटवर्क के लिए इसे fan-in और fan-out के आधार पर प्रारंभिक weights को scale करके हल किया — हर layer में आने वाले और बाहर जाने वाले connections की संख्या। Kaiming initialization (2015, He et al. के paper से) ने ReLU activations के लिए इस विचार को अनुकूलित किया, जो अलग तरह से व्यवहार करते हैं क्योंकि वे अपने आधे inputs को शून्य कर देते हैं। आधुनिक Transformers आम तौर पर इनके variants का उपयोग करते हैं, कभी-कभी attention layers के लिए ट्यून किए गए अतिरिक्त scaling factors के साथ। एक lottery ticket hypothesis (Frankle & Carlin, 2019) भी है, जिसने दिखाया कि एक randomly initialized नेटवर्क के भीतर, छोटे sub-networks मौजूद हैं — "winning tickets" — जिन्हें पूरे नेटवर्क के प्रदर्शन से मेल खाने के लिए अलगाव में प्रशिक्षित किया जा सकता है। निहितार्थ चौंकाने वाला है: उन अरबों प्रारंभिक weights में से अधिकांश अनावश्यक हो सकते हैं, और सही sparse initialization सैद्धांतिक रूप से आपको आकार के एक अंश पर वही मॉडल दे सकती है। व्यवहार में, उन winning tickets को विश्वसनीय रूप से खोजना महंगा बना हुआ है, लेकिन इस विचार ने आकार दिया है कि शोधकर्ता pruning और कुशल आर्किटेक्चर के बारे में कैसे सोचते हैं।
लोग "weights" और "parameters" का लगभग परस्पर विनिमेय रूप से उपयोग करते हैं, और अधिकांश उद्देश्यों के लिए यह ठीक है — लेकिन तकनीकी रूप से, parameters में biases (हर neuron पर weighted sum के बाद जोड़ा गया एक छोटा स्थिर) और कोई भी अन्य सीखे गए मूल्य जैसे layer normalization scales शामिल हैं। एक विशिष्ट Transformer में, biases कुल parameters का एक छोटा अंश होते हैं, इसलिए जब कोई कहता है कि एक मॉडल में 70 अरब parameters हैं, तो उनका प्रभावी रूप से अर्थ है 70 अरब weights। गहरा बिंदु यह है कि जब आप एक मॉडल की weight फ़ाइल डाउनलोड करते हैं, तो आप वह सब कुछ डाउनलोड कर रहे हैं जो मॉडल ने सीखा है। आर्किटेक्चर — कितनी layers, कितनी चौड़ी, कौन से activation functions — केवल एक ब्लूप्रिंट है। Weights इमारत स्वयं हैं। समान architectures लेकिन अलग weights वाले दो मॉडल पूरी तरह से अलग व्यवहार करेंगे यदि उन्हें अलग डेटा पर या अलग अवधि के लिए प्रशिक्षित किया गया था। यही कारण है कि "weights जारी करना" इतना महत्वपूर्ण कार्य है: आप एक डिज़ाइन साझा नहीं कर रहे हैं, आप करोड़ों डॉलर के compute और महीनों के प्रशिक्षण का संचित परिणाम साझा कर रहे हैं। ज्ञान संख्याओं में है।