የኮምፒውተር ጓደኛ መመሪያ (Brain-like Dragon Hatchling, BDH) ዘመናዊ የኒውሮል አውታረ መረብዎች ተጽዕኖዎችን መውሰድ ይችላሉ, ስዕሎች መጻፍ ይችላሉ, ወዘተ የኮምፒውተር ልውውውጥ ይሰጣሉ - ነገር ግን እነርሱ ሁሉ ተመሳሳይ መስፈርቶች ይሰጣሉ: እነርሱ . stop learning once deployed ከሁለት ሳምንታት በፊት, አንድ ቡድን ኢንጂነሪቶች እና ምርምር - Adrian Kosowski, Przemysław Uznanski, Jan Chorowski, Zuzanna Stamirowska, እና Michał Bartoszkiewicz - የሞክሮ መግዛት እና የኒውሮል መሐንዲሶች ላይ አዲስ ስሜት ይሰጣል. . 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 ይህ አሁን እንደ GPT እንደ ሞዴሎች ይሰራል: እነርሱ ከዚያም መግዛት. learn inside the egg የ Dragon Hatchling ምንድን ነው? የ BDH ንድፍ ከሁለት ዓይነት የሙዚቃ አጠቃቀም አለው: ማንኛውም መደበኛ የኒውሮል አውታረ መረብ እንደ ጤናማ መውሰድ - ይህ የኮምፒውተር መውሰድ በፊት ያውቃል. የክፍያ መሳሪያዎች, የክፍያ መሳሪያዎች, የክፍያ መሳሪያዎች, የክፍያ መሳሪያዎች, የክፍያ መሳሪያዎች, የክፍያ መሳሪያዎች, የክፍያ መሳሪያዎች, የክፍያ መሳሪያዎች, የክፍያ መሳሪያዎች, የክፍያ መሳሪያዎች, የክፍያ መሳሪያዎች, የክፍያ መሳሪያዎች, የክፍያ መሳሪያዎች, የክፍያ መሳሪያዎች የ BDH መረጃን መተግበሪያ ጊዜ, አዲስ ግንኙነት ለመፍጠር ይሆናል ሁለቱም የኒውሮን ጋር ተኳሃኝ ከሆነ, ሁለቱም መካከል ግንኙነት ይመዝገቡ. በበረራ ላይ ይህ የሚታወቁ ነው : Hebbian learning rule “የኒውሮኖች ከባድ ናቸው, ከባድ ናቸው” “የኒውሮኖች ከባድ ናቸው, ከባድ ናቸው” እነዚህን አገናኞች በአብዛኛው Matrix ውስጥ የተጠበቁ ናቸው. , ይህም በተመሳሳይ ጊዜ ተመሳሳይ ነገር ተመሳሳይ ጊዜ ካፒታል ይሰራል. አንድ ተመሳሳይ ሁኔታ በኋላ ይሆናል ከሆነ, BDH ይመዝገቡ: σ “አይ, እኔ በፊት ይህን ተመልከት ነበር - እና እዚህ ምን ይሰራል.” በ BDH ውስጥ ምን ይሆናል? የ BDH የሙዚቃ ሂደት ራሱ ያስተዋውቃል. የፕላስቲክ መሣሪያዎች, የፕላስቲክ መሣሪያዎች, የፕላስቲክ መሣሪያዎች, የፕላስቲክ መሣሪያዎች, የፕላስቲክ መሣሪያዎች, የፕላስቲክ መሣሪያዎች, የፕላስቲክ መሣሪያዎች, የፕላስቲክ መሣሪያዎች, የፕላስቲክ መሣሪያዎች የ GPU ማረጋገጫ ወይም የ GPU ማረጋገጫ አይችልም. while it works በ Go ነገር ግን - BDH is a network that learns to live, not just to repeat. ይወዳሉ, ይወዳሉ, ይወዳሉ, ይወዳሉ, ይወዳሉ እያንዳንዱ ሕንፃው የእርስዎን አግኝተዋል ልምድ አላቸው. አንድ አግኝተዋል አግኝተዋል በመጀመሪያ እግር ለመቀየቅ, ከዚያም የእርስዎን አግኝተዋል, እና ከዚያም መጨረሻው የእርስዎን አግኝተዋል. የ BDH ሞዴል ተመሳሳይ መንገድ ይከተል - የእርስዎን "እርስዎ ሕይወት" እያንዳንዱ ልምድ አንድ የተለያዩ ዓይነት አግኝተዋል. 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 Why I Believe BDH Is an Evolution, Not Just Another Model (በ BDH አንድ ልማት ነው, ብቻ ሌላ ሞዴል አይደለም) ወረቀት ይህ ብቻ የቴክኒካዊ አይደለም - ይህ በ a ይህ እውነተኛ, ማረጋገጥ የሚችል ፍላጎቶች ይሰጣል. “The Brain-like Dragon Hatchling (BDH)” (የእንጆን እንደ ንድፍ ንድፍ ንድፍ) new direction in AI architecture አጠቃቀም እና መተግበሪያ AI የቅርብ ጊዜ የ LLM ውስጥ በጣም ታዋቂ ደረጃዎች አንዱ ነው. አነስተኛ ጊዜ ያውቃል አንድ ሞዴል የተወሰነ ምርጫ ያደርጋል. BDH ይህ ይነጻል: በውስጡ "ሲናፕስ" በቀጥታ የኮምፒዩተር ግንኙነት ጋር ተመሳሳይ ነው. የ "አንድ ሞዴል" በ "አንድ ሞዴል" በ "አንድ ሞዴል" በ "አንድ ሞዴል" በ "አንድ ሞዴል" በ "አንድ ሞዴል" በ "አንድ ሞዴል" በ "አንድ ሞዴል" በ "አንድ ሞዴል" በ "አንድ ሞዴል" በ "አንድ ሞዴል" and (እንዴት በዋናነት ውስጥ እንደ) ለማስተካከል ይችላሉ እናም . opacity ለምን ያግኙን sparse positive audit reasoning processes ➡️ ይህ አስፈላጊ አካባቢዎች — የሕክምና, የገንዘብ, መብቱ — ውስጥ የሚታወቁ የቴክኒክ መሐንዲሶች መስመር ይሰጣል. አንድ ሞዴል ወደ መጨረሻው መጨረሻው ተመሳሳይ አስፈላጊ ነው. ለምን የ On-the-Fly Learning (ወደ-ወደ-ወደ-ወደ-ወደ-ወደ-ወደ-ወደ-ወደ-ወደ-ወደ-ወደ-ወደ-ወደ) የ BDH ይጠቀማል በይነገጽ ውስጥ - ይህም የኒውሮን መካከል ግንኙነት ሊኖረው ይችላል ይህ በይነገጽ ውስጥ በይነገጽ ወይም በይነገጽ ላይ ተስማሚ ይሆናል, በይነገጽ ቅርጸት ለመፍጠር ይህ "የእውነቶች" በቶኮን እና በጋቢዎች ላይ ያውቃል. Hebbian learning ምንም የፈጠራ short-term memory ➡️ ይህ LLMs ይደሰቱ — ሞዴሎች በሰውነት መንገድ, ምንም अतिरिक्त አነስተኛ መተግበሪያ olmadan, በመጀመሪያ ላይ መተግበሪያዎችን ለማሻሻል ይቻላል. lifelong learning የክፍያ እና የክፍያ በጊዜው Transformers ጋር ተጫዋቾች — አንድ ጊዜ የእርስዎን ተስማሚ የኮንክቶፕ መስኮት በላይ ይጎብኙ, ተስማሚነት ይቀበላሉ. ነገር ግን, BDH እንደ ንድፍ ነው - በይነገጽ ጥንካሬ እና የኒውሮን መጠን ይጨምራል. long-range reasoning scale-free system ➡️ ይህ ሊሆን ይችላል ለሁሉም ቀናት ወይም ሳምንታት ይሰራሉ - በ planing, researching, or simulating - without losing logical consistency. agentic systems የሞዴሎችን በባህር መውሰድ አይችልም BDH የሚታወቀው ልዩ መኖሪያ ቤት ይሰጣል : ሁለት ሞዴሎች ብቻ የእርስዎ ግራፊዎች ጋር ለመገናኘት "የመጋገብ" ሊሆን ይችላል. Transformers ጋር ተለዋዋዋጭ, ይህ አፈጻጸም ማቀዝቀዣ ወይም re-training ያስፈልጋል. model merging ➡️ እርስዎ የተለያዩ መኖሪያዎች (ወይም, የሕክምና እና የሕክምና) ከ ሞዴሎች ማተም ይችላሉ. ➡️ ይህ ለወይም መንገድ ይሰጣል እንደ ሶፍትዌር ክፍሎች እንደ ይጠቀማል የሚቻሉ "የኒውሮል ፕላኔቶች" ሊሆን ይችላል. modular AI Performance እና ውጤታማነት BDH-GPU እንደ a ይሰራል , ይህም PyTorch እና GPUs በመጠቀም ውጤታማ ማጠናቀቅ ሊሆን ይችላል. — በከፍተኛ ደረጃ እንደ በከፍተኛ ደረጃ እንደ transformer stacks. state-space system መስመር ➡️ ይህ ጠንካራ ሞዴሎች ለመፍጠር ይቻላል የ BDH ለወንዶች እና የ startups ተስማሚ ሊሆን ይችላል. 10M–1B parameter range የ Neuromorphic Computing ጋር ግንኙነት የ BDH በተለምዶ የተመሠረተ ነው እና የተሻለ ተስማሚ ነው Chip እንደ ወይም በሲሊኒየም ላይ በቀላሉ የቢዮሎጂያዊ አውታረ መረብዎችን ይምረጡ. neurons synapses neuromorphic hardware Loihi TrueNorth ➡️ ይህ ለመጫወት አማራጮች ይሰጣል የኃይል ውጤታማነት ሮቦቲክ መድረኮች, ወይም bio-inspired ስርዓቶች. large-scale reasoning models edge devices “Axiomatic AI” ወደ አንድ ደረጃ የኮምፒውተር ባለሙያዎች በይነገጽ መተግበሪያዎች የሚከተሉትን ክወናዎች ብቻ አይደለም, ነገር ግን ይህ እንደ "ይነገጽ የሙቀት መዋቅር" ማውረድ ይሆናል: ትክክክለኛ ስኬሚካል ስኬሚካል ስኬሚካል ስኬሚካል ስኬሚካል. Axiomatic AI formally predicted over time ➡️ ይህ ገጽ ወደ በመጠቀም የተሻለ ነው — የገንዘብ እና የሕክምና ከ የመጓጓዣ ወደ. certifiable and safe AI architectures autonomous, high-stakes environments አንድ ቀላል የኒውሮል አውታረ መረብ ለመፍጠር በእርግጥ BDH እንዴት ይሰራል መውሰድ, እኔ አንድ አነስተኛ የኮምፒውተር ማረጋገጫ - አንድ የ XOR ግምገማዎች ላይ የተመሠረተ ነው. (የእውነተኛ ቅርጸት ይሰጣል) ይህ አነስተኛ ፕሮጀክት የ C++ ኮርፖሬሽን (PyTorch) የተመሠረተ ነው. የ BDH መተግበሪያዎች በአሁኑ ጊዜ እንዴት እንደሚሰራ ሊሆን ይችላል, ነገር ግን የእኔ ትክክለኛነት አይደለም - ይህ ቀላልነት ነበር. minimal “tiny-BDH” in Rust autograd via tch-rs libtorch በ Python 11 መስኮች ውስጥ የኒውሮል አውታረ መረብ ሙሉ ኮድ በ GitHub repo ውስጥ ይገኛል. ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ከታች ማንኛውም የ BDH ውስጣዊ ጥያቄዎች. ጂ.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም. maximum transparency and accessibility ጂ.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም.ኤም. መኪና.toml ይህ ምሳሌ በ በ A ጋር ይጀምራል የፕሮጀክት እና የፕሮጀክቱ እና የፕሮጀክቱ ክወናዎችን ያካትታሉ. Rust Cargo.toml ዋናው ክብደት እዚህ ነው አንድ ደህንነቱ የተጠበቀ ቅርጸት ይሰጣል የ C++ ካፒታል, ይህም PyTorch ያደርጋል. ይህ ለእኛ መግቢያ ይሰጣል አግኙን , እና ሌሎች ዋና ባህሪያት ከ Rust ላይ በቀላሉ የላቀ ማወቅ. tch libtorch tensors autograd BDH እንደ የሚታወቀው ባህሪያት ይጠቀማል እና የ PyTorch መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ በ BDH ውስጥ በጣም ቀላል ቅርጸት. የኒውሮን ሻጋታዎች learning logic Here’s the relevant snippet from : 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"] } 💡 የ download-libtorch ባህሪያት Cargo ለ OS እና የአካል ብራክቶሪዎን ለጥፍ libtorch binaries መግዛት እና ያካትታል ይህ feature tells Cargo to automatically fetch and link the correct የእርስዎ የ OS እና መዋቅር ለ binaries. በእርስዎ የ PyTorch መጫን እና የ PyTorch መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ ለመጫን. በመስመር ላይ, ሁሉም ነገር "እነርሱ ብቻ ይሰራል" - Cargo መጫወት ወቅት ካፒታልን ማውረድ እና ያካትታል. download-libtorch libtorch LIBTORCH እርስዎ መጫን ላይ የተለያየ ሊሆን ይችላል.) (የእውነተኛ ስሪት) tch የእኛን አነስተኛ BDH መኖሪያ ቤት / main.rs መኖሪያ ቤት / main.rs በ Rust ፕሮጀክቶች ውስጥ, ሁሉም ምንጭ ፋይሎች በ አግኝቷል, ይህ አንድ ሁሉም ነገር አንድ ፋይል ውስጥ ይጠበቃል - የሚፈልጉትን ባህሪያት መውሰድ እና መውሰድ ገጽ መፍጠር ይሆናል: 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 GPUs ማንኛውም ማረጋገጫ ያደርጋል. የ CUDA አግኝቷል ከሆነ, ኮድ የመጀመሪያው GPU ይምረጡ: Device::Cuda(0). የ CUDA (የ Mac ወይም በ CPU ብቻ ስርዓተ ላይ) አጠቃቀም አይችልም ከሆነ, በ default በ Device::Cpu ይቀበላል. የ Variable is then passed into other components such as ይህ እነዚህን መሣሪያዎች ተመሳሳይ መሣሪያ ላይ የተመሠረተ እና ያካትታል. 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); We start with a flat array of 12 numbers ( የ XOR አጠቃላይ አጠቃቀም አጠቃቀም አጠቃቀም አጠቃቀም አጠቃቀም አጠቃቀም አጠቃቀም አጠቃቀም አጠቃቀም 4 × 3 [0, 0, 1] [0, 1, 1] [1, 0, 1] [1, 1, 1] የመጀመሪያው ሁለት ዋጋዎች binary input ናቸው ( እና (በአንድ ጊዜ የ 3 ኛ ደረጃ ነው) አግኙን (እኛም ይሆናል) ), ሞዴል በይነገጽ በይነገጽ ውሂብ ይሰጣል. X₁ X₂ bias 1 Then ይህ ቅርንጫፍ በ A የፕላስቲክ ፎቶዎች - 4 ፎቶዎች, እያንዳንዱ ከ 3 ፎቶዎች ያካትታል. የ Tensor ወደ የተመሠረተ መሣሪያ (GPU ወይም CPU) ይመዝገቡ, ሁሉም የኮምፒዩተሮች አንድ ቦታ ውስጥ ሊሆን ይችላል. .reshape([4,3]) 4×3 .to_device(dev) ሁለተኛው የቴሌቪዥን, ያካትታል የ እያንዳንዱ ውሂብ: y expected outputs [0], [1], [1], [0] እነዚህ በ XOR truth table ጋር ተስማሚ ናቸው: 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 — የ Matrices E እና D ለ ዝቅተኛ ደረጃ መጠን, በይነገጽ እና በይነገጽ ውሂብ መጠን ያካትታል. u = 0.20 — የ fast memory σ ለ መውሰድ ፍጥነት ነው; ከፍተኛ ደረጃዎች ከ "የመውሰድ" ፍጥነት ያደርጋል. hebb_lr = 0.01 — የ hebbian updates አግኝታ ፍጥነት — አዲስ መተግበሪያዎች σ ለማሻሻል እንዴት ይቆጣጠራል. በ BDH ውስጥ, መውሰድ አንድ ልዩ መገናኘት ማታሪክስ ያካትታል. በአሁኑ ጊዜ ይህ ሞዴል የተመሠረተ ክብደት (እነዚህ በ gradient descent የተከናወረ ነው) መክፈል አይችልም. የጽሑፎች, የጽሑፎች, የጽሑፎች, የጽሑፎች, የጽሑፎች, የጽሑፎች, የጽሑፎች, የጽሑፎች, የጽሑፎች, የጽሑፎች, የጽሑፎች, የጽሑፎች, የጽሑፎች, የጽሑፎች, የጽሑፎች, የጽሑፎች, የጽሑፎች Hebbian Memory: σ (sigma) synaptic memory which neurons were active together ይጀምራል : smax = 1.0 — በ σ ውስጥ ከፍተኛው ግንኙነት ጥንካሬን ያካትታል, ከባድ ዋጋዎችን መከላከያ. sparsity_thresh = 5e-3 — በጣም አነስተኛ σ ዘዴዎች ይቀበላሉ, የሙዚቃ አነስተኛ እና አስተማማኝ ይቀበላሉ. lr = 5e-3 — በአዳም optimizer የ regular model parameters (E, D, R_in, W_read) ለማሻሻል. ደረጃዎች = 3000 — ስልጠና መተግበሪያዎች ቁጥር (የ ሞዴል ውሂብ አግኝቷል ብዙ ጊዜ). Initializing Parameters and the “Neural Field” የ Hyperparameter አጠቃቀም አጠቃቀም — አንድ መጋቢት, ይህም መረብ ውስጥ ሁሉንም ተሞክሮ ተሞክሮዎች እና ተሞክሮዎች ያካትታል. ከዚያም ሞዴል ውስጥ ተሞክሮ ተሞክሮዎች ያካትታል — የ "የተሞክሮዎች", እነርሱ መተግበሪያ ወቅት ማሻሻል ይሆናል: 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 — በኒውሮል መስኮት ወደ ውሂብ ፕሮጀክሽን. E, Dx, Dy — ውስጣዊ ተለዋዋጭነት, ከባድ ደረጃዎች ጋር ተለዋዋጭ ነው. ነገር ግን መውሰድ: BDH በባድ ደረጃዎች አይሆንም — ይህ ከባድ ደረጃዎች ጋር ተመሳሳይ የኒውሮን መስኮት ይሆናል. — the , used to read the network’s final activations. w_read output projection የ Optimizer እና ፈጣን አስማሚ Next, we initialize the , አንድ ታዋቂ ቅርጸት ከባድ ዝቅተኛ ነው, ይህም ራስ-ሰር መግቢያ ፍጥነት በእያንዳንዱ ፓርሜትር ያተኮሩ ነው. እኛ ደግሞ አንድ tensor ለመፍጠር አንድ ካሬ ይህ የ BDH ን ያገለግላል. የኮምፒውተር connections between neurons and is updated at every training step. Adam optimizer σ [n × n] fast Hebbian memory የመጨረሻው let mut opt = nn::Adam::default().build(&vs, lr)?; let mut sigma = Tensor::zeros(&[n, n], (Kind::Float, dev)); for step in 0..steps { ... } Inside this training loop, we’ll add the code that teaches our “Dragon Hatchling” while it’s still in its — ይህ, በ offline pre-training ውስጥ ነው. 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); እዚህ step by step ምን ይሆናል: x_neu = x.matmul(&r_in) — ውሂብ በይነገጽ ገጽ ውስጥ ይመጣል. y1 = relu_lowrank_forward(...) — ውሂብ ማቀዝቀዝ, ያካትታል, እና አንድ ReLU መተግበሪያ በኩል ይሰጣል. a = x_neu.matmul(&sigma.T) — በተሳካ የኒውሮን አያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያያ y2 = y1 + a — የ "አሁኑ" ስሜት እና የ Short-Term Memory ጋር ተኳሃኝ ነው — ይህ የ BDH ኮንፈረንስ ስሜት ነው. z እና logits — የመጨረሻ ሂደት እና ውፅዓት ፕሮጀክሽን, ሞዴል ጥንካሬ እና ረጅም ጊዜ ጥንካሬ ጥንካሬ ያካትታል. ምርት ከባድ ከባድ ከባድ ከባድ እነርሱ የ መዋቅር በፊት - የመዋቅር በፊት የድራክኖስ ከባድ ስሜቶች. logits sigmoid raw predictions ዝቅተኛ ደረጃ + ReLU Helper እርስዎ ያውቃሉ, እዚህ በ forward pass ውስጥ ጥቅም ላይ የሚጠቀሙ የ ReLU Helper ነው: /// 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] } ይህ a አንድ ትልቅ ጥንካሬ ሜትሪክስ helyett እኛ እንደ ጋር አግኙን አግኙን . low-rank linear layer with ReLU W ∈ R^{n×n} W ≈ E · Dᵀ E ∈ R^{n×d} D ∈ R^{n×d} d ≪ n ትክክለኛ ነው: አንተ የፕሮጀክት በ compact latent space መጠን ለ XOR እንደ አነስተኛ ዲማዎች ይህ አብዛኛውን ጊዜ አስገራሚ ነው; ለ GPT-scale ሞዴሎች የሙዚቃ ደህንነት ሊሆን ይችላል (እንዴታዎች ላይ ይመልከቱ) don’t need all possible synapses d massive መስመር 3 በከፍተኛ መጠን "የኒውሮል መስኮት" (n ባህሪያት) በ d መጠን ውስጥ ውስጣዊ ውስጣዊ መስኮት ይሸፍናል. ቀጣይ መስመር በ D. ከ decoder ሞዴሎች አንድ መስመር ጥቅል እንደ n ወደ ይቀላቀሉ. አብዛኛውን ጊዜ ይህ በ W ≈ E · DT ጋር አንድ ብቻ ጥቅል እንደ ይሰራል, ነገር ግን (n^2) helyett 2nd parameter ይጠቀማል. አግኝቷል, Backprop, Step አሁን መደበኛን ያግኙ — ውጭ ማውረድ, backprop መጀመር, ውሃዎች ለማሻሻል: 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 የሙዚቃ የሙዚቃ አቅርቦት (σ) መጨረሻው ክፍል - እና በእርግጥ የ BDH ቱሪስ - ይህ ነው . It runs እያንዳንዱ መጠን የተረጋጋ ይሆናል: 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 አግኝቷል : ፈጣን (የይብብብል) የአሁኑ ክወና ጋር ተስማሚ ይሆናል ፎቶዎች ( አግኝቷል (የአምላክ) እና በአብዛኛው መጠን (የአንጻሚነት + ግምገማዎች) working memory forgets u compact stable እኛ የተገነባው ነገር እኛ ጋር አንድ አውታረ መረብ ይሰራል የምስክር ወረቀት ውስጥ የተመሠረተ ስልጠናዎች: two Slow Learning — የፈጠራ ደረጃዎች (E, D, R_in, W_read) ለመፍጠር የክሊኒካዊ backprop. ፈጣን መግዛት — የ σ ማትሪክስ በይብብብል መተግበሪያዎች / ስልጠና ውስጥ. በእርግጠኝነት የ 3 ክፍሎች - — because, as the authors note, it’s not fully specified yet. Designing that mechanism is nontrivial and በዚህ ግምገማ ውስጥ, የዚህ ግምገማዎች በከፍተኛ ደረጃ ላይ ብቻ ነው. leave out transferring fast memory into long-term weights beyond the scope How to Run It # 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 ወደ ኮንሰል መውሰድ የእርስዎን መሣሪያዎችን እና ውጤቶችን ለማረጋገጥ ቀላል ለማግኘት, አንዳንድ ቀላል መሣሪያዎችን ያካትታሉ. 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) ትክክለኛ ሁኔታዎች ልምድ በኋላ, ሞዴል ግምገማዎች መውሰድ: 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) ጋር vs. ምንም ፈጣን መታወቂያ (σ) የ Hebbian Memory አግኝቷል ጊዜ ጥምረት ተመሳሳይ ስሜት : 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 ሙሉ የሥራ ኮድ ለማግኘት, Repository ይመልከቱ: https://github.com/ZhukMax/tiny_bdh_xor https://github.com/ZhukMax/tiny_bdh_xor ለመፍጠር, ስልጠና, እና ምናባዊ ውጤቶች ሞዴል ፈጣን ተለዋዋጭ ይሆናል, እና እርስዎ ያውቃሉ: የፕሮስ (σ = ላይ) በአብዛኛው ሙሉ ነው: [~0, 1, 1, ~0]. የ XOR ለ የሚፈልጉትን (σ = off) ተኳሃኝ: ይህ የ "ቀላቀ" ክብደት በከፍተኛ ፍጥነት የሙዚቃ አጠቃቀም አጠቃቀም ሊሆን ይችላል. 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 (XOR) አንድ ቀላል Boolean ተግባር ነው, እሱም በድር ላይ ማወቅ ይችላሉ. አጠቃቀም ( የ Hebbian Layer አግኝቷል ጊዜ — ተከታታይ, ማህበረሰብ, “እነዚህ በፊት ተመሳሳይ” — ምንም እያንዳንዱ ሞዴል የተወሰነ ነው. slow E/Dx/Dy/R_in/W_read σ context over time ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ተከታታይ (ኮንክቶፕ መውሰድ): በተመሳሳይ ተከታታይ (ኮፒ / ተያያያዙት መውሰድ) ውስጥ የቀድሞው ተያያያዙት ጃፓን መጨረሻን ይምረጡ. የክፍያ መለያዎች: የክፍያ መለያዎች - በ 20-100 ደረጃዎች ውስጥ የክፍያ ትክክለኛነት ማረጋገጥ. On-the-fly መተግበሪያ: በይነገጽ ጊዜ, "የዲጂን መቆጣጠሪያ" (የቶኮን ጓደኛ) እና ሞዴል በይነገጽ መተግበሪያዎችን አይጠቀሙን ያረጋግጡ. σ ablations: በከፍተኛ ፍላጎቶች ላይ σ on / off ጋር convergence ፍጥነት / ጥራት ተለዋዋጭ. nnz (σ) መግቢያ እና መገናኘት በጊዜ ውስጥ እንዴት ይመዝገቡ / ይመዝገቡ ይመልከቱ. የ AI Incubator ይመጣል (መጨረሻዎች) BDH ብቻ “የተፈጠራዎች ሌላ አማራጮች” አይደለም. ይህ የኒውሮል መሐንዲሶች ቀጣይ ጊዜን ይመልከቱ. የ BDH መተግበሪያ ለመቀየር ወይም የ terabytes ውሂብ የሚፈልጉት helyett, የ BDH መተግበሪያ ይቀየራል , in real time. learn not on schedule, but in the moment of action during reasoning transformers እንደ "የተግበሪያዎች" አንድ ኮርስ ለማጠናቀቅ እና የእርስዎ ዲግሪ አግኝቷል ከሆነ, ከዚያም BDH ነው — ቀጣይ የተመሠረተ, በዓለም ላይ ማመልከቻ, ስህተት, መተግበሪያ, እና ሁሉንም አዲስ ተሞክሮ ያውቃል. dragon hatchling ይህ መስመር AI ወደ የመጀመሪያው ስሜት ይቀንሳል: ብቻ probabilities ለማምረት ብቻ አይደለም, ነገር ግን . think within context and experience
