A Friendly Guide to the Brain-like Dragon Hatchling (BDH) - განიხილოთ, თუ როგორ უნდა გააკეთოთ 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 იმიტომ, რომ ახალგაზრდა დრაგონი, რომელიც უბრალოდ გაბრუნდა მისი კურსი. მას უკვე იცის, თუ როგორ უნდა ფრენა და იღებს ფერი - მაგრამ მას ჯერ კიდევ არ იცის. ეს არ იპოვებს წიგნიდან, არამედ გამოცდილებადან – პირდაპირი თვითმფრინავი - შეინახოს, რა ქმედებები დაგეხმარება და რა არა. როგორ უნდა react ეს არის Essence of New Neural Architecture, რომელიც შეუერთებს (მაგალითად, როგორც სტანდარტული ქსელები) ინვესტიციების დროს BDH — the Brain-like Dragon Hatchling classic pretraining instant, self-directed learning Neural ქსელი არის სისტემა ნეირონიები, რომელიც დაკავშირებულია "ხაზები", რომლებიც შეესაბამება. გაცნობიერად, როგორც სტუდენტს, რომელიც გაუმჯობესებს თითოეული ტესტი შემდეგ, შეამოწმოთ შეცდომებს. თუმცა, როდესაც ტესტი დასრულდა, სტუდენტმა არ იპოვებს - სასწავლო მოხდა ადრე, სანამ ტესტი. gradient descent ეს არის, თუ როგორ დღეს მოდელები, როგორიცაა GPT მუშაობს: ისინი და შემდეგ შეწყვიტოს. learn inside the egg რა ხდის Dragon Hatchling განსხვავებული? BDH განკუთვნილია პატარა smarter. მას აქვს ორი სახის მეხსიერება: მუდმივი მეხსიერება, როგორიცაა ნებისმიერი ჩვეულებრივი ნერვული ქსელი - ეს არის ის, რაც ის გაიგო, სანამ გაიგო. Temporary memory, როგორიცაა instincts, ან მოკლე დროის კავშირი იდეები. როდესაც BDH მონაცემების დამუშავება, ის შექმნა ახალი კავშირი თუ ორი ნერვონები ერთობლივად დააქტიურებენ, მათ შორის კავშირი გაძლიერდება. თვითმფრინავი ეს არის ცნობილი, როგორც : Hebbian learning rule Neurons which fire together, wire together – ნეირონიები, რომლებიც ერთობლივი იღებენ, ერთობლივი იღებენ. Neurons which fire together, wire together – ნეირონიები, რომლებიც ერთობლივი იღებენ, ერთობლივი იღებენ. ეს კონტაქტები შეიცავს განსხვავებული matrix- ში. , რომელიც ფუნქციონირებს როგორც დროული რუკა, რაც ბოლო დროს ხდება. თუ მსგავსი სიტუაცია ხდება შემდეგ, BDH აღიარებს: σ "ჰ, მე ვხედავთ ეს ადრე - და აქ არის ის, რაც მუშაობს." რა ცვლილებები ხდება BDH- ში? BDH აწარმოებს სასწავლო პროცესს. ის აწარმოებს , მიუხედავად იმისა, რომ არ იძლევა backpropagation. იგი შეუძლია შეესაბამება ახალი ინფორმაცია , გარეშე რეიტინგი ან წესი GPU კომპიუტერები. while it works Go მთავარი In other words – 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, არა მხოლოდ სხვა მოდელი ქაღალდი არ არის მხოლოდ ფიზიკური - ეს ეწვიოს a ეს უზრუნველყოფს რეალური, შეფასებული უპირატესობები. The Brain-like Dragon Hatchling (BDH) სათაური new direction in AI architecture Transparent და Interpretable AI ერთ-ერთი ყველაზე პოპულარული სიტყვები თანამედროვე LLMs არის Rarely ვიცით BDH ცვლილებები, რომ: მისი "სანიპუსები" პირდაპირი შეესაბამება კონცეფციული ურთიერთობები. თქვენ შეგიძლიათ literally რა კავშირი გაუმჯობესებს, როგორც მოდელი "მფიქრობ" გარკვეული იდეა. მისი გააქტიურება არის და (ჩვეულებრივ, ეს შეიძლება გამოიწვიოს, ისევე, როგორც ტვინის და . opacity რატომ ეს sparse positive audit reasoning processes ➡️ ეს აპირებს აღიარებადი AI- სთვის ძირითადი სფეროებში - სამედიცინო, ფინანსური, სამედიცინო, სამედიცინო, სამედიცინო, სამედიცინო, სამედიცინო, სამედიცინო, სამედიცინო, სამედიცინო, სამედიცინო, სამედიცინო, სამედიცინო, სამედიცინო, სამედიცინო, სამედიცინო, სამედიცინო, სამედიცინო და სამედიცინო. მოდელი, რომელიც მივიღა მისი მიმოხილვა, ასევე მნიშვნელოვანია, როგორც მიმოხილვა. რატომ On-the-Fly Learning (სასვლელი დროის სასწავლო) BDH გამოყენება თარგმნის დროს – რაც იმას ნიშნავს, რომ ნეირონიების ურთიერთობები შეიძლება განვითარდეს ეს შეესაბამება მომხმარებლის ან კონტაქტი რეალურ დროში, განვითარება ფორმა ეს “სახავს” იდეები tokens და paragraphs. Hebbian learning არასამთავრობო ტრენინგი short-term memory ➡️ ეს იძლევა LLMs უფრო ახლოს - მოდელები, რომლებიც მუდმივად გაუმჯობესებენ mid-conversation, როგორც ადამიანები, გარეშე დამატებითი fin-tuning. lifelong learning სტაბილური და scalable განიხილება დროს Transformers შეხვდა — ერთხელ თქვენ გააგრძელებთ მათი სასწავლო კონტაქტი ფანჯარა, კონცენტრაცია შეჩერება. BDH, თუმცა, განკუთვნილია როგორც - მისი ქცევა სტაბილურია, როგორც განიხილება გლუვი და ნეირონის რაოდენობა იზრდება. long-range reasoning scale-free system ➡️ That means we can build ეს ხარჯები იღებენ დღეები ან კი კვირის განმავლობაში — გეგმა, კვლევა, ან სმულაცია — არ დაკარგავს ლოგიკური კონფიდენციალურობა. agentic systems შეერთებული მოდელები არ შეუზღუდავი მოდელები BDH აწარმოებს უნიკალური ქონება, რომელიც გამოიყენება : ორი მოდელი შეუძლია "მაკავშირდეს" უბრალოდ მათი გრაფიკების კავშირი. განსხვავებით ტრანსპორტიორებს, ეს არ შეუზღუდავი შესრულებას და საჭიროა გადამუშავება. model merging ➡️ თქვენ შეგიძლიათ შეუერთოთ მოდელები სხვადასხვა დონეზე (მაგ. სამედიცინო და სამედიცინო) გარეშე ფინალუჟინება. ➡️ ეს აშენებს გზა შეთავაზებები, სადაც შეიძლება გამოყენებულ იქნას “სუროლის პლაჟინები”, როგორც პროგრამული კომპონენტები. modular AI Performance და ეფექტურობა BDH-GPU მუშაობს როგორც a , რაც ნიშნავს, რომ მას შეუძლია ეფექტურად ტრენინგი გამოყენებით PyTorch და GPUs. მისი პარამეტრი და კომპიუტერული ღირებულება იზრდება — არ eksponentially, როგორიცაა დიდი ტანსაცმელი stacks. state-space system Linear ➡️ ეს საშუალებას აწარმოებს ძლიერი მოდელები , რათა BDH ხელმისაწვდომია დამოუკიდებელი კვლევითი და სტატისტიკა. 10M–1B parameter range კონტაქტი Neuromorphic Computing იმიტომ, რომ BDH ბუნებრივ განმარტებულია და ეს არის სრულყოფილი Fit for ჩიპები როგორც ან Biodegradable ქსოვილის ქსოვილის ქსოვილის ქსოვილის ქსოვილის ქსოვილის ქსოვილები. neurons synapses neuromorphic hardware Loihi TrueNorth ➡️ ეს იღებს შესაძლებლობებს წასვლა ელექტროენერგიის ეფექტურობა Robot პლატფორმაები, ან bio-inspired სისტემები. large-scale reasoning models edge devices A Step Toward “Axiomatic AI” ავტომობილები აჩვენებენ იდეა — სისტემები, რომელთა ქცევა შეუძლია არა მხოლოდ შეამოწმოთ, არამედ ეს არის, როგორიცაა "მინერგიის ტერდინამიკის" აღმოაჩინება: პროგნოზირებული სტანდარტული სტანდარტული სტანდარტული სტანდარტული სტანდარტული სტანდარტული სტანდარტი. Axiomatic AI formally predicted over time ➡️ ამ მიმოხილვა განკუთვნილია გამოყენება in - ფინანსთა და ჯანმრთელობის გადამცემი გადამცემი. certifiable and safe AI architectures autonomous, high-stakes environments Simply Neural Network შექმნა იმისათვის, რომ ნამდვილად იცოდეთ, თუ როგორ მუშაობს BDH, გადაწყვიტოს, რომ შექმნათ მცირე კონცეფცია - a , ტრენინგი კლასიკური XOR პრობლემა. იგი იყენებს (სამთავრობო ბეჭდვა გარშემო , the C++ core of PyTorch). This little project was inspired by the famous , მაგრამ ჩემი მიზნით არ იყო სიჩქარე — ეს იყო სიჩქარე. გინდა, რომ განიცდიან, თუ როგორ შეიძლება BDH- ის მექანიზმი მუშაობა პრაქტიკაში. minimal “tiny-BDH” in Rust autograd via tch-rs libtorch Neural network in 11 lines of Python (ნერულური ქსელის 11 ხაზი Python- ში) სრული კოდი ხელმისაწვდომია ჩემი GitHub repo ქვემოთ, მე მივიღე განახლება ნაბიჯში ნაბიჯში. ეს შეიძლება გამოიყურებოდეს verbous, მაგრამ ეს მიზნით - მიზანი აქ არის ყველასთვის, ვინც სასიამოვნოა BDH ინტერნეტზე. იურიდიული კავშირი - იურიდიული კოდი maximum transparency and accessibility იურიდიული კავშირი - იურიდიული კოდი სატვირთო Toml ამ მაგალითად, როგორც წაიკითხა ჩვენ დაიწყებთ A ფაილი — manifesto, რომელიც განმარტავს პროექტი და მისი დამოკიდებულებები. Rust Cargo.toml ძირითადი დამოკიდებულება არის Rust wrapper გარშემო უსაფრთხო C++ ბიბლიოთეკა, რომელიც იძლევა PyTorch. იგი საშუალებას გაძლევთ ხელმისაწვდომია და , და სხვა ძირითადი თვისებები Deep Learning პირდაპირი Rust. tch libtorch tensors autograd იმიტომ, რომ BDH იყენებს ცნობილი კონცეფციები, როგორიცაა და ჩვენი მიზანი არ არის PyTorch- ის აღდგენა - ეს არის ის, რომ აღსანიშნოს PyTorch- ს. BDH- ის შემდეგ, რაც შეიძლება, ყველაზე მარტივი ფორმაში. Neurons Synapticები learning logic აქ არის დაკავშირებული 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"] } 💡 ჩამოტვირთვა-libtorch ფუნქცია გთხოვთ, რომ Cargo ავტომატურად მიიღოს და კავშირი სწორი libtorch binaries თქვენი OS და არქიტექტურა. გარეშე მას, თქვენ უნდა manually დააყენოთ PyTorch და დააყენოთ LIBTORCH გარემოს ვარიანტი. მასთან ერთად, ყველაფერი "ეს მხოლოდ მუშაობს" - Cargo ჩამოტვირთვა და კავშირი ბიბლიოთეკა დროს build. ეს არის ფუნქცია გთხოვთ, რომ Cargo ავტომატურად მიიღოს და ბმული სწორი თქვენი OS და არქიტექტურა. გარეშე ეს, თქვენ უნდა manually დააყენოთ PyTorch და დააყენოთ მასთან ერთად, ყველაფერი "დაწვრილდება" - Cargo ჩამოტვირთვა და კავშირი ბიბლიოთეკა შექმნის დროს. download-libtorch libtorch LIBTORCH შეიძლება განსხვავდეს თქვენი კონფიგურაციის მიხედვით.) (მაგონება: ეს არის სწორი ვერსია tch The Core of Our Tiny BDH- ის მახასიათებლები მთავარი / src მთავარი / src Rust პროექტებში ყველა წყარო ფაილი ცხოვრობს directory. Since this is a , ჩვენ შენარჩუნებთ ყველაფერი ერთი ფაილი - იპოვეთ საჭირო დამოკიდებულებები და set up entry point: 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) On line 6, we decide to run the computations — on the GPU or CPU: where tch::Cuda::is_available() შეამოწმებს, თუ CUDA დააყენა და იპოვებს ნებისმიერი NVIDIA GPU. თუ CUDA ხელმისაწვდომია, კოდი აირჩიებს პირველი GPU: Device::Cuda(0). თუ CUDA არ არის ხელმისაწვდომი (გალითად, Mac- ში ან მხოლოდ CPU- ის სერვერზე), ეს შეიცავს Device::Cpu. ვარიანტი მას შემდეგ, რაც სხვა კომპონენტები, როგორიცაა ასე რომ იგივე მოწყობილობაზე შექმნილია და კომპიუტერული. dev VarStore::new(dev) all tensors ტრენინგი მონაცემების შექმნა შემდეგი, ჩვენ განკუთვნილია და tensors ჩვენი პატარა XOR ნეიროური ქსელის — მისი სასწავლო კომპლექტი: 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] პირველი ორი ღირებულება binary ინტენსიები ( და ) და სამი არის სტანდარტული ჩვეულებრივ (Always ), რათა დაეხმაროს მოდელის მონაცემების გაზიანება ლინიატურად. X₁ X₂ bias 1 Then გადარჩენა ეს flat array in a მატრიკები — ოთხი ნიმუშები, თითოეული შეიცავს სამი ინტენსიური თვისებები. ტენზერის გადაზიდვა აირჩიეთ მოწყობილობს (GPU ან CPU), რათა უზრუნველყოს, რომ ყველა კომპიუტერები ხდება ერთი ადგილას. .reshape([4,3]) 4×3 .to_device(dev) მეორე ტენდენცია, შეიცავს The თითოეული input: y expected outputs [0], [1], [1], [0] ეს შეესაბამება XOR truth ტაბლეტი: 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 ქსელის Hyperparameter 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 — matrix E და D- ის დაბალი დონე, რომელიც აჩვენებს, თუ რამდენად მონაცემები შეკუმშულია და გაფართოებულია. — the forgetting rate for the fast memory σ; higher values make it “forget” faster. u = 0.20 hebb_lr = 0.01 — სასწავლო სიჩქარე Hebbian განახლებები — კონტროლი, თუ რამდენად ახალი გააქტიურება შეცვალოს σ. BDH- ში, მეხსიერება შედგება სპეციალური კავშირის მეხსიერებით. Temporary საწყისი ეს არ შეინახავს მოდულების სწავლის წონა (თეები გაქირავება გრიდიენტული ქვემოთ). instead, it remembers დასაწყისში დასაწყისში დასაწყისში დასაწყისში დასაწყისში დასაწყისში დასაწყისში დასაწყისში დასაწყისში დასაწყისში დასაწყისში. Hebbian Memory: σ (sigma) Synaptic მეხსიერება which neurons were active together შემდგომი : — limits the maximum connection strength in σ, preventing runaway values. smax = 1.0 sparsity_thresh = 5e-3 — იზოლებს ძალიან მცირე σ ელემენტებს, რათა მეხსიერება რთული და სტაბილური იყოს. lr = 5e-3 — ისწავლის სიჩქარე Adam- ის ოპტიმიზერზე, რომელიც განახლებებს რეგულარული მოდელის პარამეტრები (E, D, R_in, W_read). — number of training iterations (how many times the model sees the data). steps = 3000 დასაწყისში პარამეტრები და “ნეროვანი ფართობი” მას შემდეგ, რაც ჩვენი hyperparameters შეიცავს, ჩვენ შექმნათ a — კონტეინერი, რომელიც შეიცავს ყველა ტრენინგი შესაძლებელი წონა და ფსიქიაზები ქსელის. შემდეგ ჩვენ დაამატოთ მოდელის სასწავლო პარამეტრები - მისი "ხაზები", რომელიც განახლდება ტრენინგი დროს: 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 – ინტენსიური პროგნოზი neural field- ში. E, Dx, Dy — შიდა ტრანსპორტირება, ანალოგური წონა შეშფოთებული ფართობი. მაგრამ იმიტომ, რომ: BDH არ აქვს ფართები ჩვეულებრივი მნიშვნელობა — ეს არის უფრო, როგორც ერთ-ერთი თვითმართველობის დაკავშირებული ფართობი ნეირონი. w_read — output პროგნოზი, რომელიც გამოიყენება ქსელის საბოლოო გააქტიურება. Optimizer და სწრაფი მეხსიერება შემდეგი, ჩვენ დაიწყებთ , პოპულარული ვარიანტი gradient descent, რომელიც ავტომატურად შეესაბამება სწავლის სიჩქარე ყოველ პარამეტრი. ჩვენ ასევე შექმნათ tensor 1 სართული მასშტაბით, როგორც ჩართულია, ეს მოიცავს BDH , which stores კონტაქტები შორის ნეირონიები და განახლებულია თითოეული სასწავლო ნაბიჯზე. 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 { ... } ამ სასწავლო loop, ჩვენ დაამატოთ კოდი, რომელიც განიცდიან ჩვენი "Dragon Hatchling" ხოლო ეს ჯერ კიდევ არის მისი - ეს არის, როდესაც off-line წინასწარ სასწავლო. egg Forward Pass - Dragon's პირველი ფრენის შემდეგი კოდი ბლოკი აწარმოებს , ძირითადი კომპიუტერული ნაბიჯი, სადაც ინტენსიები შეიცვალა outputs ( ) : 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) — იპოვებს დამატებითი სინათლის Hebbian მექანიზია σ, დაფუძნებული დროული ნეირონის ასოციაციები. y2 = y1 + a - შეესაბამება "ჩვეულებრივი" სინამდვილეში და ჩვეულებრივი მექანიზმი - ეს არის BDH- ის ძირითადი იდეა. z და logits - საბოლოო დამუშავების და output პროგნოზი, რომელიც შეუერთებს მოდელის краткосрочных და გრძელვადიანი ცოდნა. წარმოება aren’t yet passed through a ისინი აჩვენებენ, რომ დასაწყისში დასაწყისში დასაწყისში დასაწყისში დასაწყისში დასაწყისში. logits sigmoid raw predictions Low-Rank + ReLU დახმარება როგორც დაპირებული, აქ არის ReLU დახმარება, რომელიც ჩვენ გამოიყენებთ forward pass: /// 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 დიდი dens matrix ნაცვლად ჩვენ ვფიქრობ, რომ როგორც ერთად და და low-rank linear layer with ReLU W ∈ R^{n×n} W ≈ E · Dᵀ E ∈ R^{n×d} D ∈ R^{n×d} d ≪ n იდეა მარტივი: თქვენ Project into a compact latent space ზომა XOR- ს როგორიცაა მცირე დომები, ეს ძირითადად აჩვენებს; GPT-scale მოდელები, მეხსიერების შეზღუდვა შეიძლება იყოს (სამთავრობო სიჩქარით და სიჩქარით) don’t need all possible synapses d massive ხაზი 3 კომბინირებს მაღალი დონეზე “ნეროვანი ფართობი” (n ფუნქციები) ზომა d. შემდეგი ხაზი გააუმჯობესებს იგი დასაწყისში n-ზე, როგორც D- ის დეკორატორების ნიმუშების ხაზოვანი კომბინაცია. ერთად, ეს მუშაობს, როგორც W ≈ E · DT- ის ერთჯერადი გაუმჯობესება, მაგრამ იყენებს 2nd პარამეტრები (n^2) ნაცვლად. დახურვა, 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(); These four lines are the : შეამციროს შეცდომა, შეამციროს, თუ როგორ უნდა შეამციროს მოდელი, და გამოიყენოთ განახლება. თითოეული განახლება შემდეგ, ქსოვილის მოწინააღმდეგება სწორი გადაწყვეტილება. heart of the training loop Hebbian Fast Memory განახლება (σ) ბოლო ნაწილი - და ნამდვილად ძირითადი BDH twist - არის ეს იღებს და შენარჩუნებს სტაბილური ღირებულებები: 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 — კლასიკური backprop, რომელიც აშენებს მუდმივი წონა (E, D, R_in, W_read). სწრაფი სასწავლო — Hebrew განახლებები σ მატრიქსის დროს შედუღების / სასწავლო. გულისხმობს თებერვალი 3 - – იმიტომ, რომ, როგორც აღწერილი, ეს არ არის სრულყოფილი. დიზაინი, რომ მექანიზმი არის nontrivial და ამ მიმოხილვა; მაშინაც კი კვლევის დოკუმენტი მხოლოდ მაღალი დონეზე ამ გზა. 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 როგორც დასაწყისში, რამდენიმე ათასობით ნაბიჯების შემდეგ ქსელის converges ( და ) და პროგნოზი 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) საბოლოო პროგნოზი მას შემდეგ, რაც ტრენინგი, დატოვოთ მოდელის პროგნოზიები: 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 მეხსიერება არის vs : 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 შექმნა, სასწავლო და პროგნოზი შედეგები მოდელი სწრაფად converges, და თქვენ შეგიძლიათ იხილოთ, რომ: ნომერი (σ = on) თითქმის სრულყოფილია: [~0, 1, 1, ~0]. Preds (σ = off) match - რაც 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 არის მარტივი Boolean ფუნქცია, რომელიც ქსელის შეუძლია გაიგოს მისი კონტაქტი ( The Hebbian Layer-ის გამოხატვა shines when there’s - სექციები, ასოციები, "მაგონება ადრე" - არ არის, როდესაც თითოეული ნიმუში არის დამოუკიდებელი. slow E/Dx/Dy/R_in/W_read σ context over time რა უნდა შეამოწმეთ შემდეგი, რათა ნახოთ σ Pay Off სექციები (კონტაქტო მეხსიერება): პროგნოზი დასრულების სიმბოლოზე, რომელიც აჩვენა ადრე იგივე სექციაში (კოპი / ასოციაციური აღიარება). Balanced-parentheses tasks — check pairing correctness across 20–100 steps. Long-range dependencies: On-the-fly განკუთვნილია: განკუთვნილია, რომ “ინექციონირება ახალი წესის” (ტოკონის პარტი) და შეამოწმეთ, რომ მოდელი გამოიყენებს იგი, გარეშე გრიდიენტული განახლებები. σ ablations: შედარებით convergence სიჩქარე / ხარისხის ერთად σ on / off უფრო რთული პროგნოზი სამუშაოები. Log nnz(σ) და შეამოწმოთ, თუ როგორ კავშირები გაუმჯობესება / განკუთვნილია დროს. AI Incubator არის დაახლოებით (სახლებით) BDH არ არის უბრალოდ "მარიანტი Transformers." ეს არის მიმოხილვა შემდეგი ასაკის ნერვული არქიტექტურა - მათ, რომ იმისა, რომ დაველოდოთ აღდგენა ან მოითხოვოს terabytes მონაცემების, BDH განკუთვნილია რეალურ დროში learn not on schedule, but in the moment of action during reasoning თუ ტრანსპორტიორები, როგორიცაა “ სტუდენტები”, რომლებიც კურსის დასრულდა და მათი დოკუმენტი, მაშინ BDH არის სტუდენტები. - ახალი დასაწყისში, განიხილოს მსოფლიოში, შეცდომებს, განკუთვნილია და აღიარებს ყველა ახალი, რაც ის შეხვდება. dragon hatchling ამ გზა იღებს AI დაბრუნებას მისი დასაწყისში: არა მხოლოდ კომპიუტერების შესაძლებლობები, არამედ . think within context and experience
