Phase 10: LLMs from Scratch

असिनक और हॉगविल्ड!

अनुमानात्मक डिकोडिंग (चरण 10 · 15) एक अनुक्रम के भीतर टोकन को समानांतर करता है। बहु-एजेंट फ्रेमवर्क पूरे अनुक्रमों के पार समानांतर होते हैं लेकिन स्पष्ट समन्वय (मतदान, उप-कार्य विभाजन) को मजबूर करते हैं। हॉगविल्ड! इन्फेरेंस (रोडियोनोव एट अल, arXiv:2504.06261) कुछ और करता हैः SHARED कुंजी-मूल्य कैश के खिलाफ समानांतर में एक ही LLM के N उदाहरण चलाएं। प्रत्येक कार्यकर्ता दूसरे कर्मचारी के उत्पन्न टोकन को तुरंत देखता है। आधुनिक तर्क मॉडल QwQ, DeepSeek-R1 बिना किसी ठीक-ठाक के उस साझा कैश के माध्यम से स्वयं-समन्वित कर सकते हैं। यह दृष्टिकोण प्रयोगात्मक है लेकिन यह निष्कर्ष समानांतर के एक पूरी तरह से नई धुरी खोलता है जो विशिष्टता को डीकोड करने के लिए ओर्थोगनल बैठता है। यह सबक एक दो-कामगार Hogwild लागू करता है! stdlib पायथन में सिम्युलेटर और बताता है कि साझा कैश सहयोग मौजूदा मॉडल की तर्क क्षमताओं से क्यों उभरता है।

Type: Build

Languages: Python (stdlib)

Prerequisites: Phase 10 · 12 (inference optimization), Phase 10 · 15 (speculative decoding)

Time: ~60 minutes

सीखने के लक्ष्य

तीन सामान्य समानांतर-एलएलएम टॉपॉलजी (मतदान, उप-कार्य, हॉगविल्ड) का वर्णन करें और उन समस्याओं का नाम बताइए जो प्रत्येक लक्ष्य को संबोधित करती हैं।
मुख्य हॉगविल्ड! सेटअप का वर्णन करेंः कई कर्मचारी, एक साझा KV कैश, स्वयं-प्रशंसित के माध्यम से उभरते समन्वय।
कार्यकर्ता की गणना के रूप में हॉगविल्ड की दीवार-समय गति गणना करेंN, कार्य स्तर पर समानांतरता p, और समन्वय ओवरहेड c. .
एक खिलौना समस्या पर दो-कामगार हॉगविल्ड! सिम्युलेटर लागू करें और उभरते कार्य विभाजन का निरीक्षण करें।

समस्या

आधुनिक एलएलएम तर्क की लंबी श्रृंखलाओं का उत्पादन करके कठिन समस्याओं को हल करते हैं 5000 टोकन चरण-दर-चरण तर्क आम है, गहरे गणित समस्याओं पर हजारों टोकन होते हैं। 70 बी मॉडल पर 35 टोकन / सेकंड डिकोड पर, 50k टोकन 24 मिनट है। इंटरैक्टिव मॉडल नहीं है।

अनुमानित डिकोडिंग (चरण 10 · 15) आपको एक अनुक्रम के भीतर समानांतर करके 3-5x गति प्रदान करता है। पिछले कि ऑटोरेग्रेसिव डिकोडिंग की अनुक्रमिक निर्भरता हार्ड छत है। प्रत्येक नया टोकन प्रत्येक पिछले टोकन पर निर्भर करता है।

स्पष्ट प्रश्नः क्या हम अनुक्रमों के पार समानांतर कर सकते हैं? एक ही समस्या पर एक ही मॉडल की कई प्रतियां चलाएं, उन्हें सहयोग करने दें, उन्हें काम को विभाजित करें?

पूर्व कार्यः मतदान समूह (एन मॉडल चलाएं, बहुमत का उत्तर चुनें), विचार-वृक्ष (शाखा तर्क पथ और पुनः संयोजन), और बहु-एजेंट ढांचे (प्रत्येक एजेंट को एक उप-कार्य सौंपें, एक समन्वयक का उपयोग करें) । ये सभी विशिष्ट कार्य डोमेन में मदद करते हैं। वे सभी स्पष्ट समन्वय मशीनरी भी पेश करते हैं मतदान नियम, शाखा-और-संयोजन तर्क, एजेंट-से-एजेंट संदेश प्रोटोकॉल।

हॉगविल्ड! तर्क एक अलग दृष्टिकोण लेता है। N श्रमिकों को एक ही KV कैश साझा है। प्रत्येक कार्यकर्ता दूसरे कर्मचारी द्वारा उत्पन्न टोकन को तुरंत देखता है, जैसे कि वे उसका स्वयं का संदर्भ हैं। बिना किसी प्रशिक्षण या सूक्ष्म समायोजन के श्रमिकों को काम को कैसे विभाजित किया जाए, यह पता चल जाता है। आधुनिक तर्क मॉडल (QwQ, DeepSeek-R1, क्लाउड-परिवार तर्क मोड) साझा कैश पढ़ सकते हैं और इस तरह की बातें कह सकते हैं "मैं कार्यकर्ता 2 पहले से ही आधार मामले को संभाला है, इसलिए मैं प्रेरक कदम पर काम करूंगा। "

स्पीडअप अप्रैल 2026 से वर्कलोड पर निर्भर और प्रयोगात्मक है। लेकिन यह विचार जानना लायक है क्योंकि यह निष्कर्ष समानांतरता की एक नई धुरी खोलता है।

अवधारणा

सेटअप

N कार्यकर्ता प्रक्रियाओं को आरंभ करें, सभी एक ही LLM चल रहे हैं। प्रति कार्यकर्ता KV कैश के बजाय, एक साझा कैश बनाए रखें। जब कार्यकर्ता iटोकन उत्पन्न करता है t_j, टोकन अगले स्थान पर साझा कैश में लिखा जाता है. जब कार्यकर्ताkअगले कदम पर, यह कैश की वर्तमान स्थिति पढ़ता है (जिसमें अब तक सभी N श्रमिकों द्वारा उत्पन्न किए गए सभी शामिल हैं) ।

चरण समय पर, श्रमिक टोकन लिखने के लिए दौड़ते हैं। प्रति कार्यकर्ता स्थिति सूचकांक नहीं है कैश एक एकल बढ़ते क्रम है। आदेश को लिखने के आगमन समय द्वारा निर्धारित किया जाता है।

समन्वय क्यों उत्पन्न होता है

श्रमिकों को एक संकेत साझा करना चाहिए। आमतौर पर कुछ इस तरह "आप इस समस्या पर एक साथ काम करने वाले N उदाहरणों में से एक हैं। प्रत्येक उदाहरण साझा स्मृति को पढ़ता है और देख सकता है कि अन्य उदाहरणों ने क्या लिखा है। अति आवश्यक काम से बचें". शीघ्र और साझा कैश पर्याप्त है। तर्क मॉडल कैश पढ़ते हैं, ध्यान देते हैं कि समस्या के किन हिस्सों पर पहले ही प्रयास किया गया है, और (अक्सर लेकिन हमेशा नहीं) अनजान हिस्सों पर पिवोट करते हैं।

हॉगविल्ड! पेपर (रोडियोनोव एट अल, 2025) में इस तरह के अवलोकनों की रिपोर्ट की गई हैः

कर्मचारी योजनाएं तैयार करते हैं और उन्हें कैश के माध्यम से अन्य श्रमिकों को सूचित करते हैं।
श्रमिकों को अन्य श्रमिकों के तर्क में त्रुटियों का ध्यान मिलता है और उन्हें बाहर बुलाते हैं।
जब कोई योजना विफल होती है तो श्रमिक अनुकूल होते हैं और विकल्पों का प्रस्ताव देते हैं।
जब कर्मचारियों को काम से निकालने की जाँच करने के लिए कहा जाता है, तो वे इसे पहचानते हैं और घूमते हैं।

इन सभी में से किसी को भी सूक्ष्म समायोजन की आवश्यकता नहीं है। उभरते व्यवहार मॉडल की पहले से ही तर्क क्षमताओं से आता है।

नामकरण

पेपर का नाम हॉगविल्ड! एसजीडी (रेच और सहयोगियों, 2011) पर रिफ करता है, जो एक असिनक्रोनस-अपडेट ऑप्टिमाइज़र है। एनालॉगः एसजीडी के असिनक्रोनस श्रमिक सभी साझा पैरामीटर वेक्टर पर लिखते हैं; हॉगविल्ड! इन्फेरेंस के श्रमिक सभी साझा केवी कैश पर लिखते हैं। दोनों सिंक्रनाइज़ेशन गारंटी के बजाय अनुभवजन्य अभिसरण पर भरोसा करते हैं।

RoPE इसे ट्रेस करने योग्य बनाता है

रोटरी पोजीशन एम्बेडिंग्स (RoPE, Su et al. 2021) Q और K वेक्टरों में घूर्णन के माध्यम से स्थिति जानकारी को एन्कोड करते हैं। क्योंकि पोजीशन घूर्णन हैं और बेक-इन ऑफसेट नहीं हैं, तो एक टोकन की स्थिति KV कैश प्रविष्टि को पुनः गणना किए बिना बदल सकती है। जब कार्यकर्ता iस्थिति पर साझा कैश में लिखता है p, अन्य श्रमिकों को उस स्थिति को पढ़ने के लिए सीधे कैश प्रविष्टि का उपयोग कर सकते हैं कोई पुनः रोटेशन की आवश्यकता नहीं है।

एक सीखे-स्थिति या पूर्ण-स्थिति मॉडल में, Hogwild! को प्रत्येक समवर्ती लेखन पर कैश अमान्य करने की आवश्यकता होगी। RoPE कैश को स्थिर रहने देता है।

दीवार समय गणित

चलोT_serialएक कार्यकर्ता के लिए समस्या को अकेले हल करने का समय हो।pकार्य स्तर पर समानांतर अंश हो सकता है.cप्रत्येक चरण समन्वय ओवरहेड (विस्तारित कैश को पढ़ना, यह तय करना कि क्या लिखना है) होना चाहिए।

एकल कार्यकर्ता के लिए समयः T_serial. .

N-कार्यकर्ता Hogwild! समय, यदि समन्वय मुक्त हैः T_serial * ((1 - p) + p / N)क्लासिक अम्डाल.

समन्वय ओवरहेड के साथः T_serial ((1 - p) + p / N) + c steps_per_worker. .

एक कार्यकर्ता के लिए उत्पादक होना,c5k+ टोकन उत्पन्न करने वाले तर्क मॉडल पर, श्रमिक समन्वय के सैकड़ों टोकन खर्च कर सकते हैं और अभी भी आगे आ सकते हैं। लघु चैट कार्यों पर समन्वय हावी होता है और हॉगविल्ड! धारावाहिक से भी बदतर है।

ठोस उदाहरण

तर्क समस्याः 10k टोकन सोच श्रृंखला. मान लीजिए समस्या हैp = 0.7समानांतर सामग्री (विभिन्न प्रमाणन रणनीतियों, विभिन्न मामले विश्लेषण) और c = 200प्रति कार्यकर्ता समन्वय ओवरहेड के टोकन।N = 4श्रमिकों

सीरियल समयः 10000 डिकोड चरण।
हॉगविल्ड! समयः 10000 (0.3 + 0.7 / 4) + 200 4 = 10000 * 0.475 + 800 = 5550 डिकोड चरण।
गतिः 10000 / 5550 = 1.8x।

यह मामूली है. लेकिन लंबे तर्क समस्याओं पर (50k टोकन), समन्वय ओवरहेड अमूर्तता और गति बढ़ा 2.5-3x धक्का है. Hogwild! एक भाषा में धागे स्तर समानांतरता के निष्कर्षण समकक्ष है जो आपको बहु-धारे कोड स्वाभाविक रूप से लिखने की अनुमति देता है।

जब होगविल्ड तक पहुँचने के लिए!

लंबी तर्क समस्याएं (हजारों टोकन) जहां कार्य को स्वतंत्र उप-उद्देश्यों के पार समानांतर किया जा सकता है।
तर्कशील मॉडल जो कदम-दर-चरण सोचने के लिए प्रशिक्षित किए गए हैं। गैर- तर्कशील मॉडल आत्म-समन्वित नहीं होते हैं।
साझा कैश प्लस N वर्कर प्रक्रियाओं को रखने के लिए पर्याप्त VRAM के साथ एकल-नोड तैनाती। कैश साझा किया जाता है, लेकिन प्रत्येक कार्यकर्ता की अपनी सक्रियण स्मृति है।

कब नहीं करना

संक्षिप्त इंटरैक्टिव चैट. समन्वय ओवरहेड हावी है.
कार्य जो समानांतर नहीं होते (एक ही रैखिक प्रमाण, एक ही संकलन) । N = 1 अधिकतम है।
तर्कहीन मॉडल, कोई समन्वय नहीं आता है।
मल्टी-नोड तैनाती। साझा कैश को बहुत तेजी से क्रॉस-वर्कर सिंक्रनाइज़ेशन की आवश्यकता होती है। इंट्रा-नोड ठीक है; क्रॉस-नोड एक विलंबता आपदा है।

प्रयोगात्मक स्थिति

अप्रैल 2026 तक, हॉगविल्ड! एक अनुसंधान पद्धति है जिसमें एक ओपन-सोर्स PyTorch कार्यान्वयन है। उत्पादन को अपनाने का कोई कार्यक्रम नहीं हुआ है। तीन ब्लॉकरः

समवर्ती प्रक्रियाओं के बीच साझा KV कैश प्रबंधन गैर-नाजी इंजीनियरिंग है।
तत्काल समन्वय कार्य-निर्भर है; बेंचमार्क अभी भी बनाए जा रहे हैं।
अनुमानित डिकोडिंग पहले से ही प्रदान करता है की तुलना में स्पीडअप मामूली हैं, और दोनों को संयुक्त किया जा सकता है लेकिन संयुक्त इंजीनियरिंग एक और परत है।

यह जानने लायक है, प्रयोग करने लायक है, अभी तक किसी उत्पाद पर दांव लगाने लायक नहीं है।

इसे बनाओ

code/main.pyएक खिलौना Hogwild! सिम्युलेटर लागू करता हैः

दो श्रमिक प्रक्रियाएं, प्रत्येक एक निर्धारात्मक "एलएलएम" जो ज्ञात संभावनाओं के साथ कई टोकन श्रेणियों (कार्य-चिह्न, अवलोकन-चिह्न, समन्वय-चिह्न) में से एक का उत्पादन करती है।
एक साझा कैश (केवल टोकन की सूची) जो दोनों श्रमिक पढ़ते और लिखते हैं।
एक सरल समन्वय तर्कः जब एक कार्यकर्ता देखता है कि दूसरे ने एक श्रेणी में पहले ही पर्याप्त कार्य टोकन उत्पन्न किए हैं, तो वह एक अलग श्रेणी चुनता है।

सिम्युलेटर एक निश्चित चरण बजट के लिए चलाया जाता है और रिपोर्ट करता हैः

कुल उत्पादित कार्य टोकन।
कुल दीवार समय (कर्मियों के चरणों की संख्या)
एक एकल कार्यकर्ता पर प्रभावी गति।
एक निशान जो कार्यकर्ता किस टोकन लिखा था।

चरण 1: साझा कैश

एक सूची है कि दोनों श्रमिकों को जोड़ने के लिए. सरल ताला (पाइटन threading.Lock) वास्तविक कार्यान्वयन में; हम एक काउंटर के साथ सिमुलेशन।

चरण 2: श्रमिक लूप

प्रत्येक कार्यकर्ता, प्रत्येक चरण परः

वर्तमान साझा कैश पढ़ता है।
यह तय करता है कि पहले से मौजूद वस्तुओं के आधार पर किस श्रेणी के टोकन को लिखना है।
एक टोकन लिखता है।

चरण 3: समन्वय हेरिस्टिक

यदि श्रेणी X में पहले से ही कैश में K टोकन हैं और कार्यकर्ता की इच्छित श्रेणी X है, तो कार्यकर्ता श्रेणी Y पर स्विच करता है। यह तर्क-मॉडल व्यवहार के लिए एक खिलौना है "यह पहले से ही कवर किया गया है, इसके बजाय कुछ और करें।"

चरण 4: मापा गया गति

N=1 श्रमिक और N=2 श्रमिकों के साथ सिम्युलेटर चलाएं, समान कुल चरण बजट। उत्पादित कार्य टोकन गिनें। N=2 को समन्वय-चालित कार्य विभाजन के कारण लगभग 1.5-1.8 गुना अधिक कार्य टोकन उत्पन्न करना चाहिए।

चरण 5: समन्वय पर जोर दें

समन्वय हेरिस्टिक की संवेदनशीलता को कम करें। फिर से चलाएं। ध्यान दें कि अच्छे समन्वय के बिना, N=2 समान टोकन पैदा करता है और गति घट जाती है। यह पेपर के अवलोकन से मेल खाता हैः चाल केवल तभी काम करती है जब श्रमिकों के पास आत्म-संयोजन करने की तर्क क्षमता होती है।

इसका प्रयोग करें

अप्रैल 2026 से उत्पादन में होगविल्ड! का एकीकरण अनुसंधान-ग्रेड है। यांडेक्स/एचएसई/आईएसटी से संदर्भ कार्यान्वयन पायटॉर्च आधारित है और इसका उद्देश्य डीपसेक-आर 1 और क्यूक्यू मॉडल पर एकल-नोड मल्टी-प्रक्रिया सेटअप है।

व्यावहारिक अवधारण पथः

अपने तर्क-कार्य कार्यभार का प्रोफाइल बनाएं। जो टोकन खोजात्मक (कई रणनीतियाँ, केस विश्लेषण, खोज) बनाम रैखिक हैं, उनका अंश मापें।
यदि खोज प्रभुत्व, दो श्रमिकों Hogwild! प्रयोग चलाओ. दीवार समय में सुधार मापने.
यदि सुधार 1.3x से कम है, तो आप समन्वय-प्रभुत्व शासन में हैं। एकल-काम करने वाले पर वापस जाएं।
यदि सुधार 1.5x से अधिक है, तो N=4 पर धक्का दें और फिर से मापें। घटते रिटर्न आमतौर पर N=4-8 के आसपास पहुंचते हैं।

अनुमानित डिकोडिंग के साथ संयोजनः प्रत्येक हॉगविल्ड! कार्यकर्ता स्वतंत्र रूप से स्पेस डिकोडिंग का उपयोग कर सकता है। दो स्पीडअप (करीब) गुणा करते हैं, जिससे 3x स्पेस डिकोडिंग और 1.8x हॉगविल्ड! एक प्रभावी 5.4x के मुकाबले सरल एकल-कार्यकर्ता डिकोडिंग होता है।

इसे भेजें

यह सबक हमें फल देता हैoutputs/skill-parallel-inference-router.md. एक तर्क कार्यभार प्रोफ़ाइल (टोकन बजट, कार्य समानांतरता प्रोफ़ाइल, मॉडल परिवार, तैनाती लक्ष्य) को देखते हुए, यह मतदान, विचार के पेड़, बहु-एजेंट, हॉगविल्ड! और अटकलबाजी के डिकोडिंग रणनीतियों के बीच मार्ग तय करता है।

व्यायाम

दौड़ेंcode/main.pyपुष्टि करें N=2 Hogwild! विन्यास एक ही दीवार समय में N=1 बेसलाइन की तुलना में अधिक काम-टोकन उत्पन्न करता है।

समन्वय हेरिस्टिक की ताकत को कम करना (सेट coordination_weight=0.1) पुनः चलाएँ. दिखाएँ कि स्पीडअप टूट जाता है. समझाएँ क्योंः जब वे समन्वय नहीं कर सकते हैं तो श्रमिक प्रयास दोहराते हैं।

50k टोकन तर्क के लिए अपेक्षित Hogwild! गति गणना p=0.8, c=500एक 1k टोकन चैट कार्य के लिए एक ही करें p=0.3, c=200और N=4। एक जीत और दूसरा हार क्यों है?

हॉगविल्ड! पेपर के सेक्शन 4 (प्राथमिक मूल्यांकन) को पढ़ें। लेखकों की रिपोर्ट में दो विफलता मोड की पहचान करें। वर्णन करें कि बेहतर समन्वय प्रोंपट प्रत्येक को कैसे कम कर सकता है।

खेलौना में अनुमानित डिकोडिंग के साथ हॉगविल्ड! को जोड़ेंः प्रत्येक कार्यकर्ता आंतरिक रूप से 2-टोकन स्पेसिफिकेशन डिकोडिंग का उपयोग करता है। गुणात्मक गति की रिपोर्ट करें। जब दो कर्मचारी एक ही साझा कैश प्रीफिक्स का विस्तार करना चाहते हैं तो क्या लेखांकन समस्या उत्पन्न होती है?

प्रमुख शर्तें

Term	What people say	What it actually means
Hogwild!	"Parallel workers, shared cache"	N instances of the same LLM running concurrently with one shared KV cache; emergent coordination via self-prompting
Shared KV cache	"The coordination medium"	A single growing KV buffer that all workers read and write; enables instant token visibility across workers
Emergent coordination	"No training needed"	Reasoning-capable LLMs can read the shared cache and divide work without any fine-tuning or explicit protocol
Coordination overhead (c)	"Tokens spent orienting"	The per-worker cost of reading the extended cache and deciding what to do; must stay small vs total decode time
Parallelizable fraction (p)	"What can run in parallel"	Task-level parallelism: the fraction of the total work that is not intrinsically sequential
RoPE enables Hogwild!	"Rotary positions are shift-invariant"	Because positions are rotations, writing into a shared cache does not require recomputing prior tokens
Voting ensemble	"Run N, pick the majority"	The simplest parallel inference topology; useful for classification, less for long-form reasoning
Tree of thought	"Branch and prune"	Reasoning strategy that explores multiple branches and prunes; explicit coordination logic
Multi-agent framework	"Assign sub-tasks"	Each agent gets a role; a coordinator orchestrates; heavy protocol overhead

आगे पढ़ना

Rodionov et al. — Hogwild! Inference: Parallel LLM Generation via Concurrent Attention (arXiv:2504.06261) हॉगविल्ड! पेपर, QwQ और DeepSeek-R1 पर प्रारंभिक मूल्यांकन
Recht, Re, Wright, Niu — Hogwild!: A Lock-Free Approach to Parallelizing Stochastic Gradient Descent (arXiv:1106.5730, NeurIPS 2011) मूल हॉगविल्ड! नाम की उत्पत्ति
Su et al. — RoFormer: Enhanced Transformer with Rotary Position Embedding (arXiv:2104.09864) RoPE, वह गुण जो साझा कैश निष्कर्षण को व्यवहार्य बनाता है
Yao et al. — Tree of Thoughts: Deliberate Problem Solving with Large Language Models (arXiv:2305.10601) विचार के पेड़ तर्क रणनीति Hogwild! orthogonal से बैठता है
Leviathan et al. — Fast Inference from Transformers via Speculative Decoding (arXiv:2211.17192) अनुमानित डिकोडिंग, के भीतर अनुक्रम समानांतर Hogwild!
Hogwild! reference PyTorch implementation कागज के प्रयोगों के लिए सत्य का एकमात्र स्रोत

This free lesson is part of the AI Engineering from Scratch curriculum. Read the full explanation, run the lesson code, and verify the result in the interactive reader or from the repository source.

Browse the complete course catalog or open this lesson on GitHub.