LLMs में आवर्ती गहराई लूप Transformers के पीछे अंकगणित से आती है।
डोरी और GLiDE शो लूप LLMs परतों का पुनः उपयोग करके गहराई जोड़ते हैं, लेकिन लागत गणना और विलंबता में लाभ होता है; कैश विकल्प वास्तविक सेवा लागत तय करते हैं।
मुख्य बिंदु
- लूप्ड Transformers कोर वजन का पुनः उपयोग करके वे स्टोर की तुलना में अधिक परतों को निष्पादित कर सकते हैं, इसलिए आवर्ती गहराई एक मुफ्त सटीकता बूस्ट के बजाय कंप्यूटिंग और विलंबता व्यापार-ऑफ है।
- डोरी के उदाहरण से पता चलता है कि 36 संग्रहीत परतें चार कोर लूप्स के साथ 96 लेयर पास निष्पादित कर सकती हैं, जिसका अर्थ है वजन मेमोरी संग्रहित परतों का अनुसरण करती है जबकि प्रति- token कंप्यूटिंग क्रियान्वित स्तरों का पालन करती है।
- GLiDE. का मापा गया लूप लाभ मामूली था: 0.56-बिंदु की होल्ड-आउट स्कोर वृद्धि के साथ लगभग 35% उच्च औसत विलंबता आई, जिससे यह पता चला कि सुधार सेवारत लागत को सही ठहराना चाहिए।
- कैश व्यवहार और token बचत कार्यान्वयन विकल्प हैंः लूप किए गए मॉडल गैर-लूप आकार में कैश रख सकते हैं, लेकिन कम उत्पन्न tokens का मतलब जरूरी नहीं है कि कुल लागत कम हो।
- अधिक लूप गणना जोड़ते हैं, जानकारी नहीं; वे तथ्य उपलब्ध होने पर बहु-चरण तर्क में मदद कर सकते हैं, लेकिन लापता तथ्यों, सटीक अंकगणित या धीमी प्रतिक्रियाओं के लिए पुनर्प्राप्ति, उपकरण या पहले रुकने की आवश्यकता हो सकती है।
NVIDIA के डोरी के लिए प्रकाशित कॉन्फ़िगरेशन और इसके GLiDE मॉडल पर फास्टिनो की 10 नवंबर 2026 रिपोर्ट लूप किए गए Transformers के बारे में एक व्यावहारिक बिंदु बनाती हैः वे स्टोर करने से अधिक परतों को निष्पादित कर सकते हैं, लेकिन अतिरिक्त गहराई कंप्यूटिंग, विलंबता और सेवा व्यवहार में भुगतान किया जाता है। हेडलाइन अंकगणित यह है कि कोर चार बार चलाने पर डोरी प्रति token 96 लेयर पास करते हुए 36 परतें संग्रहीत कर सकता है। यह कोई टाइपो नहीं है. यह वजन साझा करना है, और इसे लागत मॉडल के रूप में पढ़ा जाना चाहिए, न कि मुफ्त सटीकता उन्नयन।
36 संग्रहीत परतों और 96 निष्पादित परतों के पीछे अंकगणित
डोरी के प्रकाशित लेआउट में 8 प्रील्यूड परतों, 20 परत कोर और 8 कोडा परतों का उपयोग किया गया है। एक सरलीकृत पुनरावृत्ति हैः
h0 = प्रील्यूड
h_{r+1} = कोर ((h_r, x; theta) r=0 से R-1 के लिए
लॉजिट्स = कोडा (h_R)
यह पुनरावृत्ति एक सरलीकरण है, प्रत्येक मॉडल के लिए विनिर्देश नहीं। कोर भार हर पास पर पुनः उपयोग किए जाते हैं, और डोरी इनपुट एक्स को प्रत्येक पास पर फिर से इंजेक्ट करता है ताकि लूप प्रश्न से दूर न हो जाए।
चूंकि प्रील्यूड और कोडा एक बार संग्रहीत किए जाते हैं, इसलिए मॉडल कुल 36 परतों को स्टोर करता है। चार कोर पास के साथ निष्पादित लेयर पास 8 + 20 गुना 4 + 8 = 96 होते हैं।
- आर = 1: संग्रहीत = 36, निष्पादित=36, अनुपात = 0.56
- आर = 2: संग्रहीत=36, निष्पादित=56, अनुपात=1.56
- आर = 3: संग्रहीत=36, निष्पादित=76, अनुपात=2.11
- आर = 4: संग्रहीत=36, निष्पादित=96, अनुपात=2.67
वेट मेमोरी संग्रहीत कॉलम का अनुसरण करती है। प्रति token पर गणना निष्पादित स्तंभ को पहले अनुमान के लिए फॉलो करती है; ध्यान और कुंजी-मूल्य कैश हैंडलिंग सटीक गणना बदलती है, इसलिए ये परत संख्याएं हैं, विलंबता मॉडल नहीं।
एक खिलौना उदाहरण व्यापार को स्पष्ट करता है: 8 ब्लॉक 3 बार चलाते हैं 24 ब्लॉक निष्पादित करते हुए केवल 8 संग्रहीत करते हैं। वजन साझा करना आकर्षक है, लेकिन यह वास्तविक 24-ब्लॉक नेटवर्क की सटीकता का वादा नहीं करता है, क्योंकि प्रत्येक पुनः उपयोग किए गए ब्लॉक को हर पास में अलग-अलग राज्य पर काम करना पड़ता है, और सीखना कि कठिन हिस्सा है।
फास्टिनो GLiDE ने लाभ पर एक मापा मूल्य रखा
फास्टिनो की अपनी 27B निर्णय मॉडल जीएलआईडीई पर रिपोर्ट सबसे स्पष्ट सार्वजनिक मूल्य टैग देती है। एक पास के साथ तुलना में, दो मध्य बैंड को दो बार लूप करने से प्रत्येक ने 0.56 अंकों द्वारा होल्ड-आउट स्कोर बढ़ाया, जिसमें 0.27 से 0.89 का 95% आत्मविश्वास अंतराल होता है। अंतरिम शून्य को बाहर करता है, इसलिए मापा गया लाभ उस मूल्यांकन में सांख्यिकीय रूप से सकारात्मक है।
एक RTX PRO 6000 पर, मध्यवर्ती विलंबता 83 एमएस से बढ़कर लूप सेटिंग के लिए 112 एमएस हो गई, लगभग 35% धीमी। क्या यह व्यापार इसके लायक है इस बात पर निर्भर करता है कि निर्णय कितना मूल्यवान है और एप्लिकेशन किस प्रतिक्रिया समय को वहन कर सकता है।
रिपोर्ट में लगभग 110 उम्मीदवार कॉन्फ़िगरेशन का भी उल्लेख किया गया है, कई असफल डिजाइन, 1B मापदंडों के नीचे कोई स्पष्ट लाभ नहीं, और एक तीसरा पास जो कारण-कारण तर्क बेंचमार्क को नुकसान पहुंचाता है।
कैश विकल्प, token बचत और कुल लागत
सरलता से, प्रत्येक लूप अपना ध्यान कैश रख सकता है, इसलिए कैश मेमोरी आर के साथ बढ़ेगी। डोरी का पेपर एक ऐसे मोड की रिपोर्ट करता है जो केवल अंतिम लूप के कुंजी-मूल्य कैश को रखता है। उस मोड में, स्मृति गैर-लूप पदचिह्न पर रहती है, और अधिकांश सटीकता लाभ बरकरार रखा जाता है। सबक सामान्य हैः लूप किए गए मॉडल के लिए, कैश वृद्धि एक कार्यान्वयन विकल्प है। hardware आकार देने से पहले सेवा मोड की जांच करें।
token बचत भी वे कर रहे हैं की तुलना में बेहतर लग सकता है. डोरी के लेखकों रिपोर्ट है कि 4 लूप उत्पादन 1.3 करने के लिए 2.5 बार कम उत्पन्न tokens एजेंटिक बेंचमार्क पर 1 लूप से. लेकिन प्रति- token लागत निष्पादित परतों के साथ बढ़ जाती है, 36 से 96 ऊपर अंकगणित में. कौन सा प्रभाव जीतता है एक अनुभवजन्य सवाल प्रति कार्यभार है. तुलना जो इसे व्यवस्थित करता है सही, जाँच किए गए कार्य प्रति कुल लागत है, जिसमें पुनः प्रयास शामिल हैं।
जब अधिक सोचने से मदद नहीं मिलती
एक सीखे हुए फ़ंक्शन को दोहराने से सुधार की कोई अंतर्निहित गारंटी नहीं होती है। तीन प्रक्षेपवक्र सभी संभव हैंः गुणवत्ता घटती रिटर्न के साथ बढ़ती रहती है, गुणवत्ता पठारों या गुणवत्ता चोटी और फिर गिर जाती है। कंप्यूटिंग सभी तीन मामलों में बढ़ता है।
एक निश्चित लूप गिनती अनुमानित और तुलना करने में आसान है, इसलिए वहां से शुरू करें। एक अनुकूली रोक नियम वास्तविक सुधार को ट्रैक करना होगा, क्योंकि आत्मविश्वास सही नहीं है। जांचें कि क्या जल्दी बाहर निकलना वास्तव में आपके सेवा ढेर में दीवार-घड़ी समय बचाता है; कागज पर एक निकास नियम और मापा गया विलंबता ड्रॉप अलग सबूत हैं।
एक लूप गिनती में प्रशिक्षित और दूसरे पर सेवा करने वाला मॉडल बह सकता है, क्योंकि इसकी आंतरिक स्थितियां प्रशिक्षण वितरण के बाहर जा सकती हैं।
लूपिंग क्या ठीक नहीं कर सकता
लूप गणना जोड़ते हैं, जानकारी नहीं। यदि आवश्यक तथ्य प्रॉम्प्ट या भार में नहीं है, तो एक ही राज्य पर अधिक पास इसे उत्पन्न नहीं कर सकते. पुनर्प्राप्ति या टूल कॉल कर सकता है। फिक्स चुनने से पहले विफलता का निदान करें:
- तथ्यों के पास है लेकिन बहु-चरण तर्क में विफल रहता हैः अधिक लूप या एक बड़ा कारण बजट का उपयोग करें।
- तथ्य गायबः पुनर्प्राप्ति या एक उपकरण का उपयोग करें।
- सही अंकगणित या गलत स्ट्रिंग्सः एक कैलकुलेटर या कोड टूल का उपयोग करें।
- सही लेकिन बहुत धीमी गति से: कम लूप का उपयोग करें।
- यह जितना अधिक समय सोचता है, उतना ही बुरा होता हैः जल्दी रुक जाता है।
लूप किए गए Transformers को उत्पादन में स्थान देने का निर्णय लेने वाले पाठकों के लिए, दो गहराई पर नज़र रखें: मेमोरी के लिए संग्रहीत परतें और कंप्यूटिंग के लिए निष्पादित परतें। कैश वृद्धि एक डिजाइन विकल्प है; डोरी दिखाता है कि यह एक-लूप आकार पर रह सकता है। प्रत्येक पास की विलंबता कीमत होती है; GLiDE ने 0.56 प्वाइंट होल्ड-आउट लाभ के लिए लगभग 35% अधिक औसत विलंबन मापा। कम tokens कम लागत का तात्पर्य नहीं करते हैं। किसी भी हाइपरपैरामीटर की तरह लूप गिनती चुनेंः प्रति कार्य प्रकार, ईमानदार विकल्पों के खिलाफ, और ताजा डेटा पर पुष्टि की गई।
स्रोत लेख में कहा गया है कि सभी संख्याएं सार्वजनिक कागजात और मॉडल कार्ड से आती हैं, जिसे AI की सहायता के साथ तैयार किया गया था, प्रत्येक संख्या को अंत में लिंक किए गए स्रोतों के खिलाफ जांच की गई थी, और लेखक ने मॉडलों का बेंचमार्क नहीं किया था। यह गाइड Looped Transformers Explained से अंकगणित का विस्तार करता है, मूल रूप से piszczek.pl पर प्रकाशित हुआ था। मूल ACT और Huginn से इतिहास जोड़ता है, chain of thought और एजेंट लूप्स के साथ तुलना, और सात इंटरैक्टिव लैब्स जहां पाठक लूप गिनती बदल सकते हैं और इन नंबरों को स्थानांतरित कर सकते हैं।
मेटा विवरणः NVIDIA Dory और फास्टिनो GLiDE लूप Transformers दिखाता है कि वे अधिक परतों को निष्पादित कर सकते हैं जो वे स्टोर करते हैं, सटीकता के लिए विलंबता का व्यापार और token बचत।
टैगः लूप Transformers , डोरी, GLiDE, Transformer गहराई, AI अनुमान
विशेष रुप से प्रदर्शित छवि: साझा परतों के माध्यम से tokens को पारित करने वाले लूप किए गए neural network का अमूर्त अनुकूल चित्रण, कोई वास्तविक लोग नहीं हैं, कोई लोगो नहीं है, कोई पाठ नहीं

Comments (0)