मस्तिष्क जैसी ड्रैगन हैचलिंग (BDH) के लिए एक अनुकूल गाइड आधुनिक तंत्रिका नेटवर्क चेहरे पहचान सकते हैं, कहानियां लिख सकते हैं, और यहां तक कि प्रोग्रामिंग साक्षात्कार भी पार कर सकते हैं - लेकिन वे सभी एक ही सीमा साझा करते हैं: वे . stop learning once deployed कुछ हफ्तों पहले, इंजीनियरों और शोधकर्ताओं के एक समूह - एड्रियान कोसोस्की, प्रज़ेमालाव यूज़नस्की, जेन कोरोस्की, ज़ुज़ानना स्टैमिरोवस्का, और माइकल बर्टोस्कीविज़ - ने एक आकर्षक लेख प्रकाशित किया, जिसमें मशीन सीखने और न्यूरो आर्किटेक्चर के क्षेत्र में एक नया विचार पेश किया गया था। . new type of artificial neural network https://arxiv.org/abs/2509.26507?embedable=true कागज खुद काफी घने है - गणित, सूत्रों और चार्ट से भरा है - लेकिन साहसी विचारों से भरा है। , अपने कुछ मिथक और सरलताओं के साथ। popular-science overview एक युवा ड्रैगन को कल्पना कीजिए जो सिर्फ अपने कोशिका से टूट गया है. यह पहले से ही उड़ना और आग को सांसना जानता है - लेकिन यह अभी तक नहीं जानता है यह किताबों से नहीं सीखता है, बल्कि अनुभव से - उड़ान के बीच में - याद रखता है कि कौन से कार्य मदद करते हैं और कौन से नहीं। कैसे प्रतिक्रिया करें यही है सच्चाई : एक नया न्यूरोलिक वास्तुकला जो संयुक्त है (जैसे मानक नेटवर्क में) निगरानी के दौरान BDH — the Brain-like Dragon Hatchling classic pretraining instant, self-directed learning एक तंत्रिका नेटवर्क न्यूरोनों का एक प्रणाली है जो "वजनों" द्वारा जुड़े होते हैं जो इसे समायोजित करते हैं , धीरे-धीरे गलतियों को कम करना - जैसे कि एक छात्र हर परीक्षण के बाद गलतियों की समीक्षा करके सुधार करता है. हालांकि, एक बार परीक्षण समाप्त हो गया है, छात्र अब नहीं सीखता है - सीखना पहले हुआ, परीक्षण से पहले। gradient descent जीपीटी जैसे आज के मॉडल कैसे काम करते हैं: वे और फिर रुकें। learn inside the egg क्या ड्रैगन हैचलिंग को अलग बनाता है? बीडीएच थोड़ा स्मार्ट डिज़ाइन किया गया है. इसमें दो प्रकार की स्मृति है: स्थायी स्मृति, किसी भी सामान्य तंत्रिका नेटवर्क की तरह - यह है कि यह हिचकिचाने से पहले सीखा। अस्थायी स्मृति, प्रेरणा की तरह या विचारों के बीच संक्षिप्त कनेक्शन। जब BDH जानकारी को संसाधित करता है, तो यह नए कनेक्शन बनाता है यदि दो न्यूरोन एक साथ सक्रिय होते हैं - उनके बीच का कनेक्शन मजबूत होता है। उड़ान पर यह कहा जाता है कि यह : Hebbian learning rule "न्यूरोन जो एक साथ जलाते हैं, एक साथ तार। "न्यूरोन जो एक साथ जलाते हैं, एक साथ तार। इन कनेक्शनों को अलग मैट्रिक्स में संग्रहीत किया जाता है , जो हाल ही में हुई घटनाओं का एक अस्थायी नक्शा के रूप में कार्य करता है। यदि बाद में एक समान स्थिति होती है, तो BDH याद दिलाता है: σ "अह, मैंने इसे पहले देखा है - और यहां यह काम करता है। BDH के साथ क्या बदलाव आएगा? BDH सीखने की प्रक्रिया खुद को बदलता है. यह सीखता है , यहां तक कि बैकप्रोपेजिंग चलाने के बिना. यह नई जानकारी के लिए अनुकूलित कर सकता है , फिर से प्रशिक्षण या भारी जीपीयू गणना के बिना। while it works जाओ पर दूसरे शब्दों में - BDH is a network that learns to live, not just to repeat. खड़े होने, उड़ने और आग को सांस लेने के लिए सीखना प्रत्येक जीवित प्राणी के पास अपनी सीखने के चरण होते हैं. एक ड्रैगन हैचलिंग पहले खड़े होने के लिए सीखता है, फिर अपने पंखों को फ्लैप करने के लिए, और अंततः आग को सांस लेने के लिए। Stage 1: Standing (Classic Pretraining) This is where BDH learns, like any traditional neural network. It’s trained on data, adjusts weights via gradient descent, and minimizes loss — the familiar supervised learning phase. Think of it as the dragon strengthening its legs before taking the first flight. At this stage, the model is trained on a large dataset — text corpora, translations, and other examples. It uses standard , an optimizer like , and a that predicts the next token. offline backpropagation AdamW loss function During this process, BDH develops its , referred to as in the paper (the ). These correspond to what, in a transformer, would be parameters like , and so on. permanent weights “G” fixed ruleset Wq, Wk, Wv, W1, W2 Stage 2: Flying (Online Adaptation) Once training ends, most networks stop changing. But BDH keeps learning in real time. It has a — a fast-acting connection map that updates itself during inference. If certain neurons activate together, their connection grows stronger; if not, it weakens. This is how BDH adapts to new situations mid-flight, without retraining. Hebbian memory During inference — when BDH reads or generates text — it updates its , denoted as , or “synaptic weights.” temporary internal states σ(i, j) This process isn’t gradient descent. Instead, it follows a : local learning rule If neuron and neuron fire together → strengthen their connection σ(i, j). i j This simple rule implements — often summarized as Hebbian learning “neurons that fire together, wire together.” These updates are : they exist only while a dialogue or reasoning session is active. Once σ is reset, the model returns to its original “hatched” knowledge — the way it was trained before flight. short-lived Stage 3: Breathing Fire (Self-regulation) BDH doesn’t just strengthen all connections — it keeps them balanced. The model uses sparsity thresholds and normalization to prevent runaway feedback loops. It learns to "breathe fire" carefully — powerful, but controlled. Too much activation would lead to instability; too little would make it unresponsive. The balance between those extremes is what gives BDH its “life”. The paper briefly mentions an intriguing idea: if the are preserved and averaged over time, BDH could develop something resembling — a mechanism akin to slowly updating its core weights. However, the authors haven’t yet formalized the exact algorithm for this process. Hebbian updates (σ) long-term memory They suggest that: operates on short timescales — minutes or a few hundred tokens. Fast memory (σ) evolves over much longer periods — days or across model updates. Slow memory (G) This opens the door to — systems that can continuously acquire new knowledge without erasing what they already know. Unlike classic transformers, which suffer from , BDH hints at a future where models can lifelong learning catastrophic forgetting remember their past while growing into the future. यदि न्यूरो एक न्यूरो एक साथ आग → अपने कनेक्शन σ(i, j) को मजबूत करें। i j मैं क्यों मानता हूं कि बीडीएच एक विकास है, न कि सिर्फ एक और मॉडल कागज यह केवल सिद्धांत नहीं है - यह एक यह वास्तविक, मापने योग्य लाभ प्रदान करता है। “मस्तिष्क जैसी ड्रैगन हैचलिंग (BDH)” new direction in AI architecture पारदर्शी और व्याख्याशील AI आधुनिक एलएलएम में सबसे बड़ी दर्द बिंदुओं में से एक है हम शायद ही कभी जानते एक मॉडल ने एक विशेष निर्णय लिया। बीडीएच बदलता है कि: इसके "सिनाप्स" सीधे अवधारणात्मक रिश्तों के अनुरूप हैं। जो कनेक्शन मजबूत करते हैं क्योंकि मॉडल एक निश्चित विचार के बारे में "विचार" करता है। और (जैसे मस्तिष्क में भी), यह डिबग करने और यहां तक कि . opacity क्यों देखो sparse positive audit reasoning processes ➡️ यह महत्वपूर्ण क्षेत्रों – चिकित्सा, वित्त, कानून – में व्याख्या योग्य एआई के लिए दरवाजा खोलता है – जहां समझ एक मॉडल अपने निष्कर्ष तक पहुंच गया है, खुद के निष्कर्ष के रूप में महत्वपूर्ण है। क्यों उड़ान पर सीखना (Inference-Time Learning) BDH लागू करता है अंतर्दृष्टि के दौरान भी - जिसका अर्थ है कि न्यूरोनों के बीच कनेक्शन विकसित हो सकते हैं यह वास्तविक समय में उपयोगकर्ता या संदर्भ को अनुकूलित करता है, एक रूप का विकास करता है यह टोकन और अनुच्छेदों के माध्यम से विचारों को "सूचना" करता है। Hebbian learning बिना पुनरावृत्ति short-term memory ➡️ यह एलएलएम को करीब लाता है - मॉडल जो मनुष्यों की तरह मध्यम बातचीत में सुधार जारी रखते हैं, बिना किसी अतिरिक्त फिनिंग के। lifelong learning समय के साथ स्थिर और स्केलेबल तर्क Transformers के साथ संघर्ष - एक बार जब आप उनके प्रशिक्षित संदर्भ विंडो से परे जाते हैं, तो निष्पक्षता टूट जाती है। - इसके व्यवहार स्थिर रहते हैं क्योंकि तर्क गहराई और न्यूरोन की संख्या बढ़ जाती है। long-range reasoning scale-free system ➡️ इसका मतलब है कि हम निर्माण कर सकते हैं जो दिनों या यहां तक कि हफ्तों तक चलते हैं - योजना बनाना, अनुसंधान करना या सिमुलेशन करना - बिना तार्किक स्थिरता खोने के। agentic systems विनाशकारी भूल के बिना मिश्रण मॉडल BDH introduces a unique property called : दो मॉडल को बस अपने चार्ट को जोड़कर "उपलब्ध" किया जा सकता है. ट्रांसफार्मर के विपरीत, यह प्रदर्शन को कम नहीं करता है या फिर से प्रशिक्षण की आवश्यकता होती है। model merging ➡️ आप विभिन्न डोमेनों (उदाहरण के लिए, चिकित्सा और कानूनी) से मॉडलों को अच्छी तरह से ट्यूनिंग किए बिना जोड़ सकते हैं। , जहां दोहराया जा सकता है "न्यूरल प्लगइन" सॉफ्टवेयर घटकों की तरह जुड़े हो सकते हैं। modular AI प्रदर्शन और कुशलता BDH-GPU एक के रूप में काम करता है , जिसका अर्थ है कि इसे PyTorch और GPUs का उपयोग करके कुशलता से प्रशिक्षित किया जा सकता है. इसके पैरामीटर और गणना लागत बढ़ जाती है — एक्सपोजेनिक रूप से नहीं, जैसे बड़े ट्रांसफॉर्मर स्टैक में। state-space system लाइनर ➡️ यह शक्तिशाली मॉडल बनाने में सक्षम है , BDH को स्वतंत्र शोधकर्ताओं और स्टार्टअप दोनों के लिए सुलभ बनाता है। 10M–1B parameter range Neuromorphic Computing से जुड़े अन्य समाचार क्योंकि BDH प्राकृतिक रूप से परिभाषित होता है और यह एकदम सही फिट है जैसा कि चिप्स या जो सिलिकॉन में सीधे जैविक नेटवर्क का अनुकरण करते हैं। neurons synapses neuromorphic hardware Loihi TrueNorth ➡️ यह दौड़ने के लिए संभावनाएं खोलता है ऊर्जा प्रभावी , रोबोटिक प्लेटफॉर्म, या जैव प्रेरित सिस्टम। large-scale reasoning models edge devices एक कदम “Axiomatic AI” की ओर लेखक ने इस विचार को पेश किया है कि - जिनका व्यवहार न केवल निरीक्षण किया जा सकता है बल्कि यह "इंटेलिजेंस की थर्मोडिनामी" की खोज करने जैसा है: पूर्वानुमानित स्केलिंग कानून और स्थिर तर्क गतिशीलता। Axiomatic AI formally predicted over time ➡️ इस दिशा में उपयोग के लिए उपयुक्त - वित्तीय और स्वास्थ्य देखभाल से परिवहन तक। certifiable and safe AI architectures autonomous, high-stakes environments एक सरल तंत्रिका नेटवर्क का निर्माण वास्तव में समझने के लिए कि बीडीएच कैसे काम करता है, मैंने एक छोटे से अवधारणा सबूत का निर्माण करने का फैसला किया - एक , क्लासिक XOR समस्या पर प्रशिक्षित. यह उपयोग करता है (जिसके चारों ओर एक लकड़ी , PyTorch के सी ++ कोर)। इस छोटे से परियोजना को प्रसिद्ध , लेकिन मेरा लक्ष्य संक्षिप्तता नहीं था - यह स्पष्टता थी. मैं गहराई से समझना चाहता था कि बीडीएच के तंत्र व्यावहारिक रूप से कैसे काम कर सकते हैं। minimal “tiny-BDH” in Rust autograd via tch-rs libtorch Python के 11 लाइनों में एक तंत्रिका नेटवर्क पूर्ण स्रोत कोड मेरे GitHub रेपो में उपलब्ध है , विशेष रूप से इस लेख के लिए तैयार किया गया है. नीचे, मैं निष्पादन चरण-दर-चरण के माध्यम से चलूंगा. यह बकवास लग सकता है, लेकिन यह इरादा है - यहां लक्ष्य है BDH Internal के बारे में जानने वालों के लिए ZhukMax/tiny_bdh_xor maximum transparency and accessibility इमेज कॉपीरइट / Tiny_bdh_xor टॉम इस उदाहरण में लिखा गया है कि हम एक के साथ शुरू करते हैं फ़ाइल - प्रकटीकरण जो परियोजना और इसकी निर्भरताओं को परिभाषित करता है। Rust Cargo.toml इस पर मुख्य निर्भरता है आसपास एक सुरक्षित Rust Wrapper C++ पुस्तकालय, जो PyTorch को शक्ति देता है. यह हमें पहुंच देता है , , और गहरी सीखने के अन्य कोर विशेषताएं सीधे Rust से। tch libtorch tensors autograd क्योंकि BDH परिचित अवधारणाओं का उपयोग करता है जैसे और , यह इन मौजूदा अवलोकनों का पुनः उपयोग करने के बजाय उन्हें शून्य से पुनः लागू करने के लिए समझ में आता है। सबसे सरल संभव रूप में BDH के पीछे। न्यूरॉन्स सिंहासन learning logic यहां से संबंधित स्नैप है : Cargo.toml [package] name = "tiny_bdh_xor" version = "0.1.0" edition = "2021" [dependencies] anyhow = "1.0.100" tch = { version = "0.22", features = ["download-libtorch"] } 💡 डाउनलोड-लिबटॉर्च सुविधा Cargo को अपने OS और आर्किटेक्चर के लिए सही लिबटॉर्च बाइनरी को स्वचालित रूप से प्राप्त करने और जोड़ने के लिए कहती है। इसके बिना, आपको PyTorch को मैन्युअल रूप से स्थापित करने और LIBTORCH पर्यावरण परिवर्तक को सेट करने की आवश्यकता होगी। इस फ़ीचर Cargo को स्वचालित रूप से उधार लेने और सही लिंक करने के लिए कहता है अपने ओएस और वास्तुकला के लिए बाइनरी. इसके बिना, आपको मैन्युअल रूप से PyTorch स्थापित करने और इसे सेट करने की आवश्यकता होगी इसके साथ, सब कुछ "केवल काम करता है" - कार्गो डाउनलोड करता है और निर्माण के दौरान लाइब्रेरी से लिंक करता है। download-libtorch libtorch LIBTORCH यह आपकी सेटिंग के आधार पर भिन्न हो सकता है.) (नोट: सटीक संस्करण tch हमारे छोटे बीडीएच के कोर src/main.rs एसआरसी / Main.rs Rust परियोजनाओं में, सभी स्रोत फ़ाइलों के अंदर रहते हैं चूंकि यह एक , we’ll keep everything in a single file — आइए आवश्यक निर्भरताओं को आयात करें और प्रवेश बिंदु सेट करें: src minimal example main.rs use anyhow::Result; use tch::{nn, Device, Kind, Reduction, Tensor}; use tch::nn::{Init, OptimizerConfig}; fn main() -> Result<()> { let dev = if tch::Cuda::is_available() { Device::Cuda(0) } else { Device::Cpu }; Ok(()) } डिवाइस का चयन करें (CPU या GPU) रेखा 6 पर हम निर्णय लेते हैं कंप्यूटिंग को चलाने के लिए - GPU या CPU पर: where tch::Cuda::is_available() चेक करता है कि CUDA स्थापित है और किसी भी NVIDIA GPU का पता लगाता है। यदि CUDA उपलब्ध है, तो कोड पहले GPU का चयन करता है: डिवाइस::Cuda(0)। यदि CUDA उपलब्ध नहीं है (उदाहरण के लिए, मैक या सीपीयू-केवल सर्वर पर), तो डिवाइस::सीपीयू पर डिफ़ॉल्ट हो जाता है। Variable के इसके बाद इसे अन्य हिस्सों में शामिल किया जाता है, जैसे इस प्रकार वे एक ही डिवाइस पर बनाए गए और कंप्यूटर किए गए हैं। dev VarStore::new(dev) all tensors प्रशिक्षण डेटा का निर्माण इसके बाद हम परिभाषित करते हैं और हमारे छोटे XOR न्यूरोल नेटवर्क के लिए tensors — इसके प्रशिक्षण सेट: input output let x = Tensor::from_slice(&[ 0f32,0.,1., 0.,1.,1., 1.,0.,1., 1.,1.,1. ]).reshape([4,3]).to_device(dev); let y = Tensor::from_slice(&[0f32,1.,1.,0.]).reshape([4,1]).to_device(dev); हम 12 संख्याओं के एक फ्लैट रेंज के साथ शुरू करते हैं ( , चार XOR नमूने का वर्णन करते हुए. प्रत्येक तीन संख्याओं का एक उदाहरण है: 4 × 3 [0, 0, 1] [0, 1, 1] [1, 0, 1] [1, 1, 1] पहले दो मूल्य बाइनरी इनपुट हैं ( और ) और तीसरा एक निरंतर है हमेशा (Always) ), मॉडल को रैखिक रूप से डेटा अलग करने में मदद करता है। X₁ X₂ bias 1 तब इस flat array को a में परिवर्तित करें मैट्रिक्स – चार नमूने, प्रत्येक में तीन इनपुट विशेषताएं होती हैं। तेंसर को चयनित डिवाइस (जीपीयू या सीपीयू) पर स्थानांतरित करता है, यह सुनिश्चित करता है कि सभी गणनाएं एक स्थान पर होती हैं। .reshape([4,3]) 4×3 .to_device(dev) दूसरा टेंशन, इसमें शामिल है प्रत्येक प्रवेश के लिए: y expected outputs [0], [1], [1], [0] ये XOR सच्चाई तालिका के अनुरूप हैं: X₁ X₂ Y 0 0 0 0 1 1 1 0 1 1 1 0 0 0 0 0 1 1 1 0 1 1 1 0 नेटवर्क हाइपरपैरामीटर let n: i64 = 64; let d: i64 = 16; let u: f64 = 0.20; let hebb_lr: f64 = 0.01; let smax: f64 = 1.0; let sparsity_thresh: f64 = 5e-3; let lr: f64 = 5e-3; let steps = 3000; n = 64 - तंत्रिका क्षेत्र का आकार (संचाल में न्यूरोन की संख्या)। d = 16 - मैट्रिक्स ई और डी के लिए कम रैंक आयाम, यह परिभाषित करता है कि डेटा को कितना संपीड़ित और विस्तारित किया जाता है। u = 0.20 - त्वरित स्मृति σ के लिए भूलने की दर; उच्च मान इसे तेजी से " भूल" करते हैं। hebb_lr = 0.01 - हेबैशियन अद्यतनों के लिए सीखने की दर - नियंत्रित करता है कि नए सक्रियण σ को कैसे बदलते हैं। BDH में, स्मृति को एक विशेष कनेक्शन मैट्रिक्स द्वारा प्रतिनिधित्व किया जाता है एक अस्थायी यह मॉडल के सीखने वाले वजनों को संग्रहीत नहीं करता है (वे ग्रेडिएंट गिरावट द्वारा संचालित होते हैं). इसके बजाय, यह याद करता है , forming short-term associations — a kind of “working memory” active during inference. Hebbian Memory: σ (sigma) सिनाप्टिक स्मृति which neurons were active together जारी रखें : smax = 1.0 – σ में कनेक्शन की अधिकतम ताकत को सीमित करता है, जिससे निकलने वाले मूल्यों को रोका जाता है। sparsity_thresh = 5e-3 - बहुत छोटे σ तत्वों को शून्य करता है, जिससे स्मृति दुर्लभ और स्थिर रहती है। lr = 5e-3 - एडम अनुकूलक के लिए सीखने की दर जो नियमित मॉडल पैरामीटर (ई, डी, आर_इन, W_read) को अपडेट करती है। चरण = 3000 - प्रशिक्षण पुनरावृत्तियों की संख्या (मूर्ति डेटा को कितनी बार देखती है)। प्रारंभिक पैरामीटर और "न्यूरिक क्षेत्र" हमारे हाइपरपैरामीटर को परिभाषित करने के बाद, हम एक — a container that holds all trainable weights and biases of the network. Then we add the model’s learnable parameters — its “weights,” which will be updated during training: parameter store let vs = nn::VarStore::new(dev); let root = &vs.root(); let e = root.var("E", &[n,d], Init::Randn { mean: 0.0, stdev: 0.05 }); let dx = root.var("Dx", &[n,d], Init::Randn { mean: 0.0, stdev: 0.05 }); let dy = root.var("Dy", &[n,d], Init::Randn { mean: 0.0, stdev: 0.05 }); let r_in = root.var("R_in", &[3,n], Init::Randn { mean: 0.0, stdev: 0.20 }); let w_read = root.var("W_read", &[n,1], Init::Randn { mean: 0.0, stdev: 0.20 }); प्रत्येक परिवर्तक BDH मॉडल का एक हिस्सा परिभाषित करता है: r_in - तंत्रिका क्षेत्र में इनपुट प्रोजेक्शन। ई, डीक्स, डी - आंतरिक परिवर्तन, एक छिपे हुए परत के वजन के समान। लेकिन याद रखें: बीडीएच में सामान्य अर्थ में परतें नहीं हैं - यह न्यूरोनों के एक एकल स्वयं से जुड़े क्षेत्र की तरह है। — the , used to read the network’s final activations. w_read output projection ऑप्टिमाइज़र और तेज स्मृति इसके बाद हम शुरुआती , a popular variant of gradient descent that automatically tunes learning rates per parameter. We also create a tensor एक वर्ग एक मेट्रिक्स जो शून्य से भरा हुआ है. यह BDH का प्रतिनिधित्व करता है कौन सी दुकानें न्यूरोनों के बीच कनेक्शन और प्रशिक्षण के हर चरण में अद्यतन किया जाता है। Adam optimizer σ [n × n] fast Hebbian memory temporary let mut opt = nn::Adam::default().build(&vs, lr)?; let mut sigma = Tensor::zeros(&[n, n], (Kind::Float, dev)); for step in 0..steps { ... } इस प्रशिक्षण चक्र के भीतर, हम उस कोड को जोड़ेंगे जो हमारे "ड्रैगन हैचलिंग" को सिखाता है जबकि यह अभी भी अपने में है - अर्थात्, ऑफ़लाइन पूर्व प्रशिक्षण के दौरान। egg Forward Pass - ड्रैगन का पहला उड़ान अगले कोड ब्लॉक कार्य करता है , मुख्य गणना चरण जहां इनपुट आउटपुट में परिवर्तित होते हैं ( ) : forward pass logits let x_neu = x.matmul(&r_in); let y1 = relu_lowrank_forward(&x_neu, &e, &dx); let a = x_neu.matmul(&sigma.transpose(-1, -2)); let y2 = y1 + a; let z = relu_lowrank_forward(&y2, &e, &dy); let logits = z.matmul(&w_read); यहाँ कदम से कदम क्या होता है: x_neu = x.matmul(&r_in) - इनपुट डेटा तंत्रिका क्षेत्र में प्रवेश करता है। y1 = relu_lowrank_forward(...) - डेटा संपीड़ित किया जाता है, विस्तार किया जाता है, और एक ReLU सक्रियण के माध्यम से पारित किया जाता है। a = x_neu.matmul(&sigma.T) – अस्थायी न्यूरोन संघों के आधार पर हेब्रियन स्मृति σ से अतिरिक्त सिग्नल प्राप्त करता है। y2 = y1 + a - "वर्तमान" सिग्नल को छोटी अवधि की स्मृति के साथ जोड़ता है - यह BDH का मूल विचार है। z और logits - अंतिम प्रसंस्करण और आउटपुट प्रोजेक्शन, मॉडल के संक्षिप्त और दीर्घकालिक ज्ञान दोनों को जोड़ते हैं। उत्पादन अभी तक एक पार नहीं हो पाया वे प्रतिनिधित्व करते हैं सक्रियण से पहले - ड्रैगन के अशुद्ध विचार आकार लेने से पहले। logits sigmoid raw predictions कम रैंक + ReLU सहायक जैसा कि वादा किया गया है, यहां ReLU सहायक है जिसे हम अगले पास में उपयोग करते हैं: /// y = ReLU( (x E) D^T ) fn relu_lowrank_forward(x: &Tensor, e: &Tensor, d: &Tensor) -> Tensor { let h = x.matmul(e); // [B,n]·[n,d] = [B,d] h.matmul(&d.transpose(-1, -2)).relu() // [B,d]·[d,n] = [B,n] } यह एक एक बड़े घने मैट्रिक्स के बजाय हम इसे मानते हैं जैसे के साथ , , . low-rank linear layer with ReLU W ∈ R^{n×n} W ≈ E · Dᵀ E ∈ R^{n×d} D ∈ R^{n×d} d ≪ n विचार सरल है: आप एक कॉम्पैक्ट लैटिन अंतरिक्ष में प्रोजेक्ट XOR जैसे छोटे डेमो के लिए यह ज्यादातर उदाहरण के लिए है; जीपीटी-स्केल मॉडल के लिए स्मृति बचत हो सकती है (उत्पादित करने के लिए स्केल में) don’t need all possible synapses d massive लाइन 3 उच्च आयाम "न्यूरिक क्षेत्र" (एन विशेषताएं) को आकार डी के लैटिन अंतरिक्ष में संपीड़ित करता है। अगली पंक्ति इसे D से डिकोडर पैटर्नों के एक लाइनर संयोजन के रूप में n पर वापस बढ़ाती है. एक साथ, यह W ≈ E · DT द्वारा एक एकल गुणा के रूप में कार्य करता है, लेकिन (n^2) के बजाय 2nd पैरामीटर का उपयोग करता है. हार, बैकप्रोप, कदम अब हम मानक को जोड़ते हैं — नुकसान की गणना करें, बैकप्रोप चलाएं, वजन अपडेट करें: training step let loss = logits .binary_cross_entropy_with_logits::<Tensor>(&y, None, None, Reduction::Mean); opt.zero_grad(); loss.backward(); opt.step(); ये चार पंक्तियां हैं : त्रुटि मापें, मॉडल को ठीक करने के लिए कैसे गणना करें, और अद्यतन लागू करें. प्रत्येक पुनरावृत्ति के बाद, नेटवर्क सही समाधान के थोड़ा करीब जाता है। heart of the training loop इस्लामिक फास्ट मेमोरी अद्यतन (σ) अंतिम भाग - और वास्तव में मुख्य बीडीएच टवीस्ट - यह है चल रहा है और मान स्थिर रखता है: Hebbian fast-memory update outside autograd tch::no_grad(|| { let bsz = x.size()[0] as f64; // 1) Build co-activation map: outer = y2ᵀ @ x_neu let outer = y2 .detach() // detach from autograd .transpose(-1, -2) // [B,n]ᵀ → [n,B] .matmul(&x_neu.detach()) // [n,B] @ [B,n] → [n,n] .to_kind(Kind::Float) * (hebb_lr / bsz); // scale by batch size and Hebb LR // 2) Work on a shallow copy to avoid move/borrow issues let zeros = Tensor::zeros_like(&sigma); let mut s = sigma.shallow_clone(); // 3) Exponential forgetting + add fresh co-activations s *= 1.0 - u; // older σ fades out s += &outer; // Hebbian boost for co-firing neurons // 4) Safety rails: clamp to prevent blow-ups // (I originally skipped this and hit runtime errors during training) s = s.clamp(-smax, smax); // 5) Sparsify: zero-out tiny values (efficiency + stability) let keep = s.abs().ge(sparsity_thresh); s = s.where_self(&keep, &zeros); // 6) Row-wise normalization: stabilize the energy of σ @ x let row_norm = s.square().sum_dim_intlist([1].as_ref(), true, Kind::Float).sqrt(); s = &s / &row_norm.clamp_min(1.0); // 7) Write back into σ without changing ownership sigma.copy_(&s); }); इसे BDH के रूप में सोचें : यह तेजी से वर्तमान संदर्भ (इब्रानियन) के लिए अनुकूलित करता है, धीरे-धीरे पुराने पैटर्न ( रहते हैं (संपादित करें) और संख्या में रहता है (Camp + Normalization के बारे में) working memory forgets u compact stable हमने क्या बनाया हमने एक नेटवर्क बनाया है जिसमें learning modes described in the paper: two धीमी सीखना - क्लासिक बैकप्रॉप जो स्थायी वजन (ई, डी, आर_इन, W_read) को आकार देता है। त्वरित सीखना - निष्कर्षण / प्रशिक्षण के दौरान σ मैट्रिक्स के हिब्रू अद्यतन। हम जानबूझकर तीसरा टुकड़ा - - क्योंकि, जैसा कि लेखकों ने नोट किया है, यह अभी तक पूरी तरह से निर्दिष्ट नहीं है। इस अवलोकन से; यहां तक कि अनुसंधान कागज भी केवल उच्च स्तर पर इस दिशा को चित्रित करता है। leave out transferring fast memory into long-term weights beyond the scope इसे कैसे चलाएं # 1) Create the project and add the files cargo new tiny_bdh_xor && cd tiny_bdh_xor # (replace Cargo.toml and src/main.rs with the code above) # 2) Build & run cargo run --release जैसा कि उम्मीद की जाती है, कुछ हज़ार चरणों के बाद नेटवर्क एकजुट हो जाता है ( , ) और XOR को सही ढंग से पूर्वानुमान करता है। loss ↓ acc → 1.0 Console पर जाएं प्रशिक्षण गतिशीलता और परिणामों की जांच करना आसान बनाने के लिए, आइए कुछ हल्के लॉगिंग जोड़ें। 1) हर 300 कदम की प्रगति प्रशिक्षण के दौरान प्रिंट नुकसान और सटीकता: if step % 300 == 0 { let y_hat = logits.sigmoid(); let acc = y_hat.gt(0.5) .eq_tensor(&y.gt(0.5)) .to_kind(Kind::Float) .mean(Kind::Float) .double_value(&[]); println!("step {:4} loss {:.4} acc {:.2}", step, loss.double_value(&[]), acc); } 2) Final predictions After training, dump the model’s predictions: let x_neu = x.matmul(&r_in); let y1 = relu_lowrank_forward(&x_neu, &e, &dx); let a = x_neu.matmul(&sigma.transpose(-1, -2)); let y2 = y1 + a; let z = relu_lowrank_forward(&y2, &e, &dy); let preds = z.matmul(&w_read).sigmoid().gt(0.5).to_kind(Kind::Int64); println!("\nPred:\n{:?}", preds); 3) बिना त्वरित स्मृति के (σ) भविष्यवाणियों की तुलना करें जब हेबियन स्मृति है केस : on off // σ = on let probs = z.matmul(&w_read).sigmoid(); println!("\nProbs (σ=on):"); probs.print(); println!("Preds (σ=on):"); preds.print(); // σ = off let y1_nos = relu_lowrank_forward(&x_neu, &e, &dx); let y2_nos = y1_nos; // no 'a' term from σ let z_nos = relu_lowrank_forward(&y2_nos, &e, &dy); let preds_nos = z_nos.matmul(&w_read).sigmoid().gt(0.5).to_kind(Kind::Int64); println!("\nPreds (σ=off):"); preds_nos.print(); पूर्ण कार्य कोड के लिए, रजिस्टर देखें: https://github.com/ZhukMax/tiny_bdh_xor पूर्ण कार्य कोड के लिए, रेपोरेटरी देखें: https://github.com/ZhukMax/tiny_bdh_xor https://github.com/ZhukMax/tiny_bdh_xor निर्माण, प्रशिक्षण और पूर्वानुमान परिणाम मॉडल तेजी से मिलता है, और आप देख सकते हैं कि: प्रॉब्स (σ = चालू) लगभग सही हैं: [~0, 1, 1, ~0]। प्रीड्स (σ = बंद) मैच - जो XOR के लिए उम्मीद की जाती है: यह एक स्थिर कार्य है जिसे तेजी से स्मृति के बिना "चढ़ा" वजनों द्वारा हल किया जा सकता है। Running `target/debug/tiny_bdh_xor` step 0 loss 0.6931 acc 0.50 step 300 loss 0.0000 acc 1.00 step 600 loss 0.0000 acc 1.00 step 900 loss 0.0000 acc 1.00 step 1200 loss 0.0000 acc 1.00 step 1500 loss 0.0000 acc 1.00 step 1800 loss 0.0000 acc 1.00 step 2100 loss 0.0000 acc 1.00 step 2400 loss 0.0000 acc 1.00 step 2700 loss 0.0000 acc 1.00 Pred: Tensor[[4, 1], Int64] Probs (σ=on): 7.4008e-09 1.0000e+00 1.0000e+00 6.6654e-17 [ CPUFloatType{4,1} ] Preds (σ=on): 0 1 1 0 [ CPULongType{4,1} ] Preds (σ=off): 0 1 1 0 [ CPULongType{4,1} ] क्यों σ XOR के लिए "अच्छी" नहीं है XOR एक सरल बोलिक कार्य है जिसे नेटवर्क अपने पैरामीटर ( (Hebrew Layer के बारे में) चमकती है जब - अनुक्रम, साझेदारी, "कुछ पहले हुआ" - जब प्रत्येक नमूना स्वतंत्र नहीं है। slow E/Dx/Dy/R_in/W_read σ context over time भुगतान को देखने के लिए अगले में क्या कोशिश करें अनुक्रम (संदर्भ स्मृति): एक जोड़ी के अंतिम प्रतीक का अनुमान लगाएं जो पहले एक ही अनुक्रम में दिखाई दिया (कोपी / एसोसिएटिव रीसेल)। लंबी दूरी पर निर्भरताएं: संतुलित पैरेंटेज कार्य - 20-100 चरणों में जोड़ने की सटीकता की जाँच करें। उड़ान पर अनुकूलन: निष्कर्ष निकालने के दौरान, "एक नया नियम इंजेक्ट करें" (एक टोकन जोड़ी) और मॉडल को ग्रेडिंट अद्यतन के बिना इसका उपयोग करने की पुष्टि करें। σ ablations: कठिन पूर्वानुमान कार्यों पर समानता गति / गुणवत्ता के साथ σ चालू / बंद की तुलना करें. nnz (σ) रिकॉर्ड करें और देखें कि कनेक्शन समय के साथ कैसे मजबूत होते हैं / गिरते हैं। एआई इंक्यूबेटर निकट है (संस्करण) बीडीएच केवल "ट्रांसफार्मर के लिए एक और विकल्प" नहीं है. यह न्यूरोल आर्किटेक्चर के अगले युग में एक नज़र है - जो . Instead of waiting for retraining or requiring terabytes of data, BDH adjusts itself वास्तविक समय में। learn not on schedule, but in the moment of action during reasoning यदि ट्रांसफार्मर "विशेषज्ञों" की तरह हैं जो पाठ्यक्रम पूरा करते हैं और अपनी डिप्लोमा अर्जित करते हैं, तो बीडीएच एक - ताजा जन्म, दुनिया का पता लगाने, गलतियां करने, अनुकूलन करने और हर नई चीज को याद करने के लिए। dragon hatchling यह दिशा एआई को अपने मूल आत्मा में वापस लाती है: न केवल संभावनाओं को गणना करने के लिए, बल्कि . think within context and experience
