क्या FP8 मॉडल के जवाब बदल देता है? 120 में एक पलटा
के साथ Anagha Langhe · एक NVIDIA L4 पर अपना LLM खुद चलाती हैं · DocumentSyncAI

आधे मिनट में
Anagha Langhe अपना भाषा-मॉडल खुद चलाती हैं, एक ही ग्राफ़िक्स कार्ड पर, NVIDIA L4 पर। वे जानना चाहती थीं कि मॉडल के नंबर हल्के फ़ॉर्मैट में रखने से क्या उसके जवाब बिगड़ते हैं। यह फ़ॉर्मैट FP8 है, जो आम bf16 की तुलना में वज़न की मेमोरी लगभग 43% घटा देता है (14.3 से 8.2 GiB), इसलिए इसका लालच होना लाज़मी है।
उन्होंने दोनों बिल्ड से वही 120 सवाल पूछे: bf16 के 72 सही, FP8 के 71। सिर्फ़ एक जवाब पलटा। और जब दोनों गलत थे, तो 48 में से 42 बार गलत जवाब भी एक ही था।
Anagha ने हमारी खुली तुलना-स्क्रिप्ट अपने डेटा पर चलाई और वही आँकड़े पाए। उनका निष्कर्ष: गलतियाँ रिट्रीवल से आती हैं, यानी उस कदम से जहाँ उनका सिस्टम वे दस्तावेज़ ढूँढता है जिनसे वह जवाब देता है, हल्के फ़ॉर्मैट से नहीं।
सवाल
Anagha का सिस्टम दस्तावेज़ों के बारे में सवालों के जवाब देता है। पहले वह सही अंश ढूँढता है, फिर मॉडल उन्हीं से जवाब देता है। कोड खुला है: DocumentSyncAI।
FP8 ने वज़न की मेमोरी लगभग 43% घटाई (14.3 से 8.2 GiB), क्योंकि एम्बेडिंग और आउटपुट परतें bf16 में ही रहती हैं। एक GPU पर यही तो इसका पूरा मकसद है। चिंता भी उतनी ही सीधी है: क्या यह छोटा फ़ॉर्मैट चुपचाप जवाबों को बिगाड़ देता है?
Anagha ने इसे नापा। उन्होंने दोनों बिल्ड से वही 120 सवाल पूछे और नतीजा LinkedIn पर डाला: bf16 में 72 सही, FP8 में 71, और एक्ज़ैक्ट McNemar टेस्ट में p = 1.0 (यह टेस्ट बताता है कि फ़र्क किस्मत से ज़्यादा है या नहीं; 1.0 का मतलब फ़र्क का कोई निशान नहीं)। उसी पोस्ट में उन्होंने अपने सेटअप का एक और आँकड़ा बताया: प्रिफ़िक्स-कैश हिट रेट, यानी सर्वर कितनी बार पहले किया हुआ काम दोबारा इस्तेमाल कर पाया, 12% से बढ़कर 26% हो गया।
72 बनाम 71 "कोई फ़र्क नहीं" जैसा दिखता है। मगर 120 सवालों पर ऐसा टेस्ट सिर्फ़ बड़ी गिरावट पकड़ पाता है। तीन-चार अंकों का नुकसान शायद फिर भी न दिखे। इसलिए मायने p-मान के नहीं, इसके हैं कि हर सवाल के साथ असल में हुआ क्या।
किसने क्या किया
- Anagha ने सेटअप बनाया, दोनों बिल्ड को वही 120 सवाल पर चलाया, जवाबों को ग्रेड किया, और बाद में अपनी फ़ाइलों पर तुलना चलाई।
- हमने (Vadym Chernets) उनसे पूछा कि हर दिशा में कितने सवाल पलटे। फिर मॉडलों की सहमति जाँचने वाली अपनी एक खुली स्क्रिप्ट में छोटा
compareमोड जोड़ा, और उनके सारांश से अंतराल और योजना के आँकड़े निकाले। - जब Anagha ने वह स्क्रिप्ट अपने पूरे डेटा पर चलाई, तो वही आँकड़े आए, साथ में एक और, जो सारांश से हमें नहीं दिख सकता था: दोनों बिल्ड कितनी बार एक ही तरह से गलत थे।
आँकड़े कैसे दिखते हैं
| पैमाना | मान |
|---|---|
| सटीकता, bf16 | 72 / 120 |
| सटीकता, FP8 | 71 / 120 |
| पलटे हुए: सिर्फ़ bf16 सही / सिर्फ़ FP8 सही | 1 / 0 |
| एक्ज़ैक्ट McNemar टेस्ट | p = 1.0 |
| अंतर bf16 − FP8 | +0.8 अंक, 95% अंतराल लगभग −2.3 से +4.6 |
| शब्द-दर-शब्द एक जैसे जवाब | 120 में से 49 |
| दोनों गलत, और गलत जवाब वही | 48 में से 42 |
इसे कैसे पढ़ें। एक पलटा जवाब इस बात से पूरी तरह मेल खाता है कि FP8 की कोई कीमत नहीं है। पर यह इसका प्रमाण नहीं: दो अंकों की गिरावट भी अंतराल के भीतर आती है, यानी उस दायरे में जहाँ असली फ़र्क के होने की सबसे ज़्यादा संभावना है।
छह से कम पलटों पर एक्ज़ैक्ट McNemar टेस्ट किसी भी तरफ़ p < 0.05 तक नहीं पहुँच सकता। इसलिए यहाँ p-मान से ज़्यादा पलटे और अंतराल बताते हैं।
और एक अंक की गिरावट देखने के लिए लगभग 800 सवाल चाहिए होंगे, चाहे हर पलटा एक ही दिशा में जाए।
48 में से 42 वाली बात ने हमें चौंकाया। अगर FP8 बस मॉडल को ज़्यादा शोर वाला बनाता, तो उसकी गलतियाँ बिखरी होतीं। इसके बजाय दोनों बिल्ड उन्हीं सवालों पर अटकते हैं और उसी गलत जवाब पर पहुँचते हैं।
Anagha ने इसे यूँ कहा: यह "मेरी इस समझ से मेल खाता है कि गलतियाँ रिट्रीवल से आती हैं, क्वांटाइज़ेशन से नहीं"। जब सिस्टम गलत अंश उठा लाता है, तो दोनों बिल्ड वही गलत पाठ पढ़ते हैं और वही बात कहते हैं। साथ ही, दोनों बिल्ड को हर सवाल के लिए ठीक वही अंश मिले, इसीलिए साझा गलतियाँ इतनी अच्छी तरह मेल खाती हैं।
अपने रन पर आज़माइए
उन्हीं सवालों पर दो रन JSONL में हैं? हर पंक्ति में सवाल की आईडी, जवाब, और या तो correct फ़ील्ड या एक gold फ़ाइल चाहिए। फिर तुलना एक कमांड की बात है। यह खुली रिपॉज़िटरी memory-agreement-check का हिस्सा है, MIT लाइसेंस, कोई निर्भरता नहीं:
git clone https://github.com/vadimchernets/memory-agreement-check
cd memory-agreement-check
python -m memcheck compare bf16.jsonl fp8.jsonl --label-a bf16 --label-b FP8हर सवाल की एक पंक्ति ऐसी दिखती है:
{"qid": "q001", "answer": "Paris", "correct": true, "category": "factual"}यह 2×2 तालिका, एक्ज़ैक्ट McNemar टेस्ट और सटीकता के अंतर का अंतराल छापती है। साथ में गिनती है कि कितने जवाब एक जैसे हैं और दोनों रन कितनी बार एक ही गलत जवाब देते हैं, और अगर आपके सवालों में श्रेणियाँ हैं तो सब कुछ श्रेणी के हिसाब से बाँट देती है। --md report.md रिपोर्ट सहेज देता है।
यह क्या दिखाता है, और क्या नहीं
- 120 सवाल यह देखने के लिए काफ़ी हैं कि FP8 ने इस मॉडल को बर्बाद नहीं किया। एक-दो अंक की गिरावट न होने का वादा करने के लिए काफ़ी नहीं हैं।
- टेस्ट हर सवाल को स्वतंत्र मानता है। अगर बहुत से सवाल एक ही दस्तावेज़ या एक ही टेम्पलेट से आते हैं, तो असली नमूना 120 से छोटा है।
- "गलतियाँ रिट्रीवल से आती हैं" Anagha की अपने सिस्टम के बारे में समझ है। 48 में से 42 इसे सहारा देता है। इसे सीधे जाँचना हो तो वही सवाल एक बार सही अंशों के साथ और एक बार गलत अंशों के साथ पूछने होंगे।
आगे क्या
Anagha इस पर राज़ी हुईं कि उनकी FP8 बनाम bf16 जाँच रिपॉज़िटरी में एक हल किए उदाहरण के रूप में, उनके नाम के साथ, जाए। दो बिल्ड की तुलना करने वाले अगले व्यक्ति के पास शुरू करने के लिए सिर्फ़ बनावटी नहीं, एक असली मामला होगा।
समयरेखा
- Anagha LinkedIn पर अपनी FP8 जाँच पोस्ट करती हैं: 120 में 71 बनाम 72, McNemar p = 1.0। हम टिप्पणी करते हैं कि पलटे हुए जवाबों की गिनती p-मान से ज़्यादा बताती है। वे जवाब देती हैं, और हम पूछते हैं कि हर दिशा में कितने सवाल पलटे।
-
उनका जवाब: बस एक, bf16 सही और FP8 गलत, दूसरी दिशा में कोई नहीं, और 120 में से 49 जवाब शब्द-दर-शब्द एक जैसे। रातोंरात खुली स्क्रिप्ट में
compareमोड आ जाता है, और हम उनके सारांश से निकाले अंतराल और योजना के आँकड़े उन्हें भेजते हैं। - Anagha इसे अपने दोनों रन पर चलाती हैं: आँकड़े ठीक मिलते हैं, और जब दोनों बिल्ड गलत थे तो 48 में से 42 पर गलत जवाब एक ही था। वे हल किए उदाहरण के लिए हामी भरती हैं।