Um guia amigável para o Dragon Hatchling semelhante ao cérebro (BDH) As redes neurais modernas podem reconhecer rostos, escrever histórias e até mesmo passar entrevistas de programação – mas todas elas compartilham a mesma limitação: elas são capazes . stop learning once deployed Há algumas semanas, um grupo de engenheiros e pesquisadores – Adrian Kosowski, Przemysław Uznanski, Jan Chorowski, Zuzanna Stamirowska e Michał Bartoszkiewicz – publicou um artigo fascinante apresentando uma nova ideia no campo do aprendizado de máquina e arquiteturas neurais. . new type of artificial neural network https://arxiv.org/abs/2509.26507?embedable=true O papel em si é bastante denso – cheio de matemática, fórmulas e gráficos – mas cheio de ideias ousadas. Com algumas metáforas e simplificações. popular-science overview Imagine um dragão que acaba de sair da sua casca, já sabe voar e respirar fogo, mas ainda não sabe. Ele não aprende com livros, mas com a experiência – no meio do voo – memorizando quais ações ajudaram e quais não. Como reagir Essa é a essência do uma nova arquitetura neural que combina (como em redes padrão) com durante a inferência. BDH — the Brain-like Dragon Hatchling classic pretraining instant, self-directed learning Uma rede neural é um sistema de neurônios conectados por “pesos” que se ajustam através Reduzindo gradualmente o erro – muito como um aluno melhorando após cada teste, revisando erros.No entanto, uma vez que o teste termina, o aluno não aprende mais – o aprendizado aconteceu mais cedo, antes do teste. gradient descent É assim que os modelos de hoje como o GPT funcionam: eles E depois parar. learn inside the egg O que torna o Dragon Hatchling diferente? O BDH é projetado um pouco mais inteligente. Tem dois tipos de memória: Memória permanente, como qualquer rede neural normal - isso é o que ele aprendeu antes de pegar. Memória temporária, semelhante a instintos ou conexões de curto prazo entre pensamentos. Quando o BDH processa informações, cria novas conexões Se dois neurônios se ativam juntos, a conexão entre eles se fortalece. No voo Isso é conhecido como o : Hebbian learning rule “Neurônios que acendem juntos, fio juntos.” “Neurônios que acendem juntos, fio juntos.” Essas conexões são armazenadas em uma matriz separada , que atua como um mapa temporário do que aconteceu recentemente. Se uma situação semelhante ocorrer mais tarde, a BDH lembra: σ “Ah, eu já vi isso antes – e aqui está o que funcionou.” Quais são as mudanças com o BDH? BDH transforma o próprio processo de aprendizagem. , mesmo sem executar backpropagation. Pode adaptar-se a novas informações , sem retrabalho ou computadores GPU pesados. while it works Sobre o Go Em outras palavras – BDH is a network that learns to live, not just to repeat. Aprender a andar, voar e respirar fogo Cada criatura viva tem suas próprias etapas de aprendizagem.Um dragão aprende primeiro a ficar de pé, depois a bater as asas e, eventualmente, a respirar fogo.O modelo BDH segue um caminho semelhante – cada etapa de sua “vida” traz um tipo diferente de aprendizagem. 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. Se o neurônio e neurônios O fogo juntamente → fortalecer a sua conexão σ(i, j). i j Por que eu acredito que a BDH é uma evolução, não apenas outro modelo O papel não é apenas teórico – aponta para a Isso traz vantagens reais e mensuráveis. “The Brain-Like Dragon Hatchling” (em inglês) new direction in AI architecture Transparente e interpretável Um dos maiores pontos de dor nos LLMs modernos é Raramente se sabe BDH muda isso: suas “sinapses” correspondem diretamente a relações conceituais. que as conexões reforçam à medida que o modelo “pensar” sobre uma determinada ideia. e (assim como no cérebro), tornando possível depurar e até mesmo . opacity Porquê Veja sparse positive audit reasoning processes Isso abre a porta para a IA explicável em domínios críticos - medicina, finanças, direito - onde a compreensão A conclusão de um modelo é tão importante quanto a própria conclusão. Porquê On-the-Fly Learning (Aprendizagem em Tempo de Inferência) BDH Aplicável mesmo durante a inferência – o que significa que as conexões entre neurônios podem evoluir Adapta-se ao usuário ou ao contexto em tempo real, desenvolvendo uma forma de que “lembra” idéias através de tokens e parágrafos. Hebbian learning Sem retrabalho short-term memory ➡️ Isso empurra os LLMs mais perto de - modelos que continuam a melhorar a conversação no meio, como o faz o ser humano, sem qualquer ajuste adicional. lifelong learning Raciocínio estável e escalável ao longo do tempo Os transformadores lutam com — uma vez que você vai além de sua janela de contexto treinado, a coerência colapsa. BDH, no entanto, é projetado como um Seu comportamento permanece estável à medida que a profundidade do raciocínio e o número de neurônios aumentam. long-range reasoning scale-free system Isso significa que podemos construir que correm por dias ou mesmo semanas - planejamento, pesquisa ou simulação - sem perder consistência lógica. agentic systems Fusão de modelos sem esquecimento catastrófico BDH introduz uma propriedade única chamada : dois modelos podem ser “fusos” simplesmente conectando seus gráficos. Ao contrário dos transformadores, isso não degrada o desempenho ou requer retrabalho. model merging ➡️ Você pode combinar modelos de diferentes domínios (por exemplo, médico e legal) sem ajuste. ➡️ Isso abre o caminho para , onde “plugins neurais” reutilizáveis podem ser conectados como componentes de software. modular AI Desempenho e eficiência BDH-GPU funciona como um , o que significa que ele pode ser treinado de forma eficiente usando PyTorch e GPUs. Seus parâmetros e custos de computação aumentam — não exponencialmente como em grandes pilhas de transformadores. state-space system linearidade Isso permite a criação de modelos poderosos na , tornando o BDH acessível a pesquisadores independentes e startups. 10M–1B parameter range Conexão com a Computação Neuromórfica A BDH é naturalmente definida em termos de e É uma forma perfeita para Os chips como ou que emulam redes biológicas diretamente em silício. neurons synapses neuromorphic hardware Loihi TrueNorth ➡️ Isto abre possibilidades para correr Eficiência energética plataformas de robótica, ou sistemas bio-inspirados. large-scale reasoning models edge devices Um passo para a “AI axiomática” Os autores apresentam a ideia de sistemas cujo comportamento não só pode ser observado, mas É como descobrir a “termodinâmica da inteligência”: leis de escala previsíveis e dinâmicas de raciocínio estáveis. Axiomatic AI formally predicted over time ➡️ Este ponto para Adequado para uso em - das finanças e da saúde aos transportes. certifiable and safe AI architectures autonomous, high-stakes environments Construir uma rede neural simples Para realmente entender como o BDH funciona, decidi construir uma pequena prova de conceito - uma , treinado no problema clássico XOR. Ele usa (um rosto em redor , o núcleo C++ de PyTorch). Este pequeno projeto foi inspirado pelo famoso Mas meu objetivo não era a brevidade – era a clareza.Eu queria entender profundamente como os mecanismos da BDH poderiam funcionar na prática. minimal “tiny-BDH” in Rust autograd via tch-rs libtorch Uma rede neural em 11 linhas de Python O código-fonte completo está disponível no meu GitHub repo , preparado especificamente para este artigo. Abaixo, eu vou passar pela implementação passo a passo. Pode parecer verboso, mas isso é intencional - o objetivo aqui é Para todos os interessados em BDH. ZhukMax/tiny_bdh_xor maximum transparency and accessibility ZhukMax/tiny_bdh_xor Caminhão.toml Como este exemplo está escrito em Começamos com uma arquivo – o manifesto que define o projeto e suas dependências. Rust Cargo.toml A principal dependência é , um embrulho seguro Rust ao redor do biblioteca C++, que fornece o PyTorch. , em , e outras características fundamentais do aprendizado profundo diretamente da Rust. tch libtorch tensors autograd Porque o BDH usa conceitos conhecidos como e , faz sentido reutilizar essas abstrações existentes em vez de reimplementá-las do zero.Nosso objetivo não é recriar PyTorch - é explorar o O BDSM na forma mais simples possível. neurônios Sinapse learning logic Aqui está o clipe relevante de : 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"] } 💡 A função download-libtorch diz à Cargo que receba e conecte automaticamente os binários libtorch corretos para o seu sistema operacional e arquitetura. Sem ele, você precisaria instalar manualmente o PyTorch e definir a variável de ambiente LIBTORCH. Com ele, tudo “só funciona” — a Cargo descarrega e conecta a biblioteca durante a construção. O a função diz ao Cargo para recolher e vincular automaticamente o para o seu sistema operacional e arquitetura. sem ele, você precisaria instalar manualmente o PyTorch e definir o Com ele, tudo “apenas funciona” – Cargo descarrega e liga a biblioteca durante a construção. download-libtorch libtorch LIBTORCH pode variar dependendo da sua configuração.) (Nota: a versão exata do tch O núcleo do nosso pequeno BDH Página principal / main.rs Página principal / main.rs Em projetos Rust, todos os arquivos de origem vivem dentro do Diretor, uma vez que é um , manteremos tudo em um único arquivo - Vamos importar as dependências necessárias e configurar o ponto de entrada: 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(()) } Escolha do dispositivo (CPU ou GPU) No capítulo 6, decidimos Para executar os cálculos – na GPU ou CPU: where tch::Cuda::is_available() verifica se o CUDA está instalado e detecta quaisquer GPUs NVIDIA. Se o CUDA estiver disponível, o código seleciona a primeira GPU: Device::Cuda(0). Se o CUDA não estiver disponível (por exemplo, em um Mac ou em um servidor exclusivo da CPU), ele é definido por padrão como Device::Cpu. A variável Em seguida, é transferido para outros componentes, tais como Assim que são criados e computados no mesmo dispositivo. dev VarStore::new(dev) all tensors Criando os dados de treinamento Em seguida, definimos o e tensores para nossa minúscula rede neural XOR — seu conjunto de treinamento: 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); Vamos começar com uma matriz plana de 12 números ( ), descrevendo quatro amostras XOR. Cada triplo de números é um exemplo: 4 × 3 [0, 0, 1] [0, 1, 1] [1, 0, 1] [1, 1, 1] Os dois primeiros valores são entradas binárias ( e A terceira é uma constante Introdução (sempre ), ajudando o modelo a separar os dados linearmente. X₁ X₂ bias 1 Depois Converta este array em uma matriz — quatro amostras, cada uma com três características de entrada. Mova o tensor para o dispositivo selecionado (GPU ou CPU), garantindo que todos os cálculos ocorram em um só lugar. .reshape([4,3]) 4×3 .to_device(dev) O segundo tensor, Contém o Para cada entrada: y expected outputs [0], [1], [1], [0] Estes correspondem à tabela de verdade 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 Hiperparâmetros de rede 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 - o tamanho do campo neural (número de neurônios na camada). d = 16 - a dimensão de baixo nível para as matrizes E e D, definindo quanto os dados são comprimidos e expandidos. — the forgetting rate for the fast memory σ; higher values make it “forget” faster. u = 0.20 hebb_lr = 0,01 – a taxa de aprendizagem para as atualizações em hebraico – controla o quão fortemente as novas ativações modificam σ. Em BDH, a memória é representada por uma matriz de conexão especial. Um temporário Ele não armazena os pesos aprendidos do modelo (estes são tratados por descida de gradiente). , formando associações de curto prazo - uma espécie de "memória de trabalho" ativa durante a inferência. Hebbian Memory: σ (sigma) Memória sináptica which neurons were active together Continuando em: smax = 1.0 – limita a força máxima da conexão em σ, evitando valores de fuga. sparsity_thresh = 5e-3 – elimina elementos σ muito pequenos, mantendo a memória escassa e estável. lr = 5e-3 – taxa de aprendizagem para o otimizador Adam que atualiza os parâmetros regulares do modelo (E, D, R_in, W_read). passos = 3000 – número de iterações de treinamento (quantas vezes o modelo vê os dados). Inicialização de parâmetros e o “campo neural” Depois de definir nossos hiperparâmetros, criamos uma - um recipiente que detém todos os pesos treináveis e preconceitos da rede.Então adicionamos os parâmetros aprendíveis do modelo - seus "pesos", que serão atualizados durante o treinamento: 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 }); Cada variável define uma parte do modelo BDH: r_in – a projeção de entrada no campo neural. E, Dx, Dy – as transformações internas, análogas aos pesos de uma camada oculta.Mas lembre-se: BDH não tem camadas no sentido usual – é mais como um único campo auto-conectado de neurônios. w_read – a projeção de saída, usada para ler as ativações finais da rede. Otimização e memória rápida Em seguida, iniciamos a , uma variante popular de descida de gradiente que ajusta automaticamente as taxas de aprendizagem por parâmetro. uma praça matriz preenchida com zeros. Esta representa a matriz do BDH Quais lojas conexões entre neurônios e é atualizado em cada etapa do treinamento. Adam optimizer σ [n × n] fast Hebbian memory temporário let mut opt = nn::Adam::default().build(&vs, lr)?; let mut sigma = Tensor::zeros(&[n, n], (Kind::Float, dev)); for step in 0..steps { ... } Dentro deste ciclo de treinamento, vamos adicionar o código que ensina o nosso “Dragon Hatchling” enquanto ainda está em sua — that is, during offline pretraining. egg Forward Pass - O Primeiro Voo do Dragão O próximo bloco de código executa o , a principal etapa de computação em que as entradas são transformadas em saídas ( e) O 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); Aqui está o que acontece passo a passo: x_neu = x.matmul(&r_in) – os dados de entrada entram no campo neural. y1 = relu_lowrank_forward(...) – os dados são comprimidos, expandidos e passados através de uma ativação ReLU. a = x_neu.matmul(&sigma.T) – recupera o sinal adicional da memória hebraica σ, com base em associações neuronais temporárias. y2 = y1 + a – fusão do sinal “corrente” com a memória de curto prazo – esta é a ideia central do BDH. z e logits - a projeção final de processamento e saída, combinando tanto o conhecimento de curto e longo prazo do modelo. A produção Ainda não passaram por uma Eles representam o antes da ativação – os pensamentos não refinados do dragão antes de tomar forma. logits sigmoid raw predictions Nível mais baixo + ReLU Helper Como prometido, aqui está o assistente ReLU que usamos no 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] } Este é um Em vez de uma grande matriz densa Nós o consideramos como com , em , em . o low-rank linear layer with ReLU W ∈ R^{n×n} W ≈ E · Dᵀ E ∈ R^{n×d} D ∈ R^{n×d} d ≪ n A ideia é simples: você Projeto em um espaço latente compacto de tamanho Para pequenas demonstrações como o XOR, isso é principalmente ilustrativo; para modelos de escala GPT, as economias de memória podem ser (Terabytes em escala) don’t need all possible synapses d massive A linha 3 comprime o "campo neural" de alta dimensão (n características) em um espaço latente do tamanho d. A próxima linha expande-o de volta para n como uma combinação linear de padrões de decodificador de D. Juntos isso atua como uma única multiplicação por W ≈ E · DT, mas usa parâmetros 2o em vez de (n^2). Perda, backprop e passo a passo Agora vamos adicionar o padrão — calcular a perda, executar backprop, atualizar pesos: training step let loss = logits .binary_cross_entropy_with_logits::<Tensor>(&y, None, None, Reduction::Mean); opt.zero_grad(); loss.backward(); opt.step(); Essas quatro linhas são as : medir erro, calcular como corrigir o modelo e aplicar a atualização.Depois de cada iteração, a rede se aproxima um pouco mais da solução correta. heart of the training loop Atualização de memória rápida em hebraico (σ) A última parte – e realmente o núcleo BDH twist – é o Ele corre e mantém os valores estáveis: 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); }); Pense nisso como BDH : se adapta rapidamente ao contexto atual (hebreu), gradualmente Padrões antigos ( e permanece (esparcialidade) e permanece numéricamente (Clamp + normalização do padrão) working memory forgets u compact stable O que nós construímos Criamos uma rede com a Modos de aprendizagem descritos no artigo: two Aprendizagem lenta – backprop clássico que forma os pesos permanentes (E, D, R_in, W_read). Aprendizagem rápida - Atualizações em hebraico da matriz σ durante a inferência/treinamento. Nós intencionalmente A terceira peça – — porque, como os autores observam, ainda não está totalmente especificado. do presente resumo; mesmo o artigo de pesquisa apenas esboça esta direção em alto nível. leave out transferring fast memory into long-term weights beyond the scope Como a executar # 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 Como esperado, após alguns milhares de passos a rede converge ( , em ) e prevê XOR corretamente. loss ↓ acc → 1.0 Enviar para o console Para tornar a dinâmica do treinamento e os resultados fáceis de inspeccionar, adicione um pouco de logging leve. 1) Progresso a cada 300 passos Perda de impressão e precisão durante o treinamento: 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) Previsões finais Após o treinamento, descarte as previsões do modelo: 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) Com vs. sem memória rápida (σ) Compare as previsões quando a memória hebraica está 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(); Para um código de trabalho completo, consulte o repositório: https://github.com/ZhukMax/tiny_bdh_xor Para um código de trabalho completo, consulte o repositório: https://github.com/ZhukMax/tiny_bdh_xor https://github.com/ZhukMax/tiny_bdh_xor Construir, treinar e prever resultados O modelo converge rapidamente, e você pode ver isso: As probas (σ = on) são quase perfeitas: [~0, 1, 1, ~0]. Prede (σ = off) match — o que é esperado para XOR: é uma tarefa estática resolvível pelos pesos “lentos” sem memória rápida. 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} ] Por que σ não é “necessário” para XOR XOR é uma função booleana simples que a rede pode aprender com sua Os parâmetros ( A camada hebraica O brilho quando há Sequências, associações, “o que aconteceu antes” – não quando cada amostra é independente. slow E/Dx/Dy/R_in/W_read σ context over time O que tentar ao lado para ver σ Pagar fora Sequences (memória de contexto): Prevê o símbolo final de um par que apareceu anteriormente na mesma sequência (cópia / recall associativo). Dependências de longo alcance: tarefas de parênteses equilibradas – verifique a correção do acoplamento em 20 a 100 passos. Adaptação no voo: Durante a inferência, “injetar uma nova regra” (um par de tokens) e verificar se o modelo o usa sem atualizações de gradiente. σ ablações: Compare a velocidade/qualidade de convergência com σ on/off em tarefas de previsão mais difíceis. Log nnz(σ) e observe como as conexões se fortalecem/decadem ao longo do tempo. The AI Incubator Is Near (Conclusions) BDH não é apenas “outra alternativa aos transformadores”.É um vislumbre da próxima era das arquiteturas neurais – aquelas que Em vez de esperar por retrabalho ou exigir terabytes de dados, o BDH se ajusta. em tempo real. learn not on schedule, but in the moment of action during reasoning Se os transformadores são como “estudantes” que concluíram um curso e ganharam seu diploma, então o BDH é um - recém-nascido, explorando o mundo, cometendo erros, adaptando-se e lembrando-se de tudo o que é novo. dragon hatchling Esta direção traz a IA de volta ao seu espírito original: não apenas para calcular probabilidades, mas para . think within context and experience
