Una guía amigable para el Dragon Hatchling similar al cerebro (BDH) Las redes neuronales modernas pueden reconocer rostros, escribir historias e incluso pasar entrevistas de programación, pero todas comparten la misma limitación: . stop learning once deployed Hace unas semanas, un grupo de ingenieros e investigadores —Adrian Kosowski, Przemysław Uznanski, Jan Chorowski, Zuzanna Stamirowska, y Michał Bartoszkiewicz— publicó un fascinante artículo que introdujo una nueva idea en el campo del aprendizaje automático y las arquitecturas neuronales. . new type of artificial neural network https://arxiv.org/abs/2509.26507?embedable=true El papel en sí es bastante denso – lleno de matemáticas, fórmulas y gráficos – pero lleno de ideas audaces. con algunas metáforas y simplificaciones propias. popular-science overview Imagínese a un joven dragón que acaba de romperse de su concha.Ya sabe volar y respirar fuego, pero aún no lo sabe. No aprende de los libros, sino de la experiencia – justo en medio del vuelo – memorizando qué acciones ayudaron y qué no. Cómo reaccionar Esa es la esencia de una nueva arquitectura neural que combina (como en las redes normales) con durante la inferencia. BDH — the Brain-like Dragon Hatchling classic pretraining instant, self-directed learning Una red neural es un sistema de neuronas conectadas por "pesos" que se ajustan a través de , reduciendo gradualmente los errores - igual que un estudiante mejora después de cada prueba al revisar los errores. sin embargo, una vez que la prueba se acaba, el estudiante ya no aprende - el aprendizaje ocurrió antes, antes de la prueba. gradient descent Así es como funcionan los modelos actuales como GPT: ellos Y luego detener. learn inside the egg ¿Qué hace que el Dragon Hatchling sea diferente? El BDH está diseñado un poco más inteligente. Tiene dos tipos de memoria: Memoria permanente, como cualquier red neural normal, esto es lo que aprendió antes de hacerse. Memoria temporal, similar a los instintos o conexiones a corto plazo entre pensamientos. Cuando BDH procesa la información, crea nuevas conexiones Si dos neuronas se activan juntos, la conexión entre ellas se fortalece. En el vuelo Esto es conocido como el : Hebbian learning rule “Las neuronas que arden juntas, se fijan juntas”. “Las neuronas que arden juntas, se fijan juntas”. Estas conexiones se almacenan en una matriz separada , que actúa como un mapa temporal de lo que ha sucedido recientemente. Si una situación similar ocurre más tarde, BDH recuerda: σ “Ah, lo he visto antes y aquí está lo que funcionó”. ¿Cuáles son los cambios con BDH? BDH transforma el propio proceso de aprendizaje. , incluso sin ejecutar retropropaganda. puede adaptarse a la nueva información , sin retraining o pesados cálculos de GPU. while it works En el camino En otras palabras - BDH is a network that learns to live, not just to repeat. Aprender a ponerse de pie, volar y respirar fuego Cada criatura viva tiene sus propias etapas de aprendizaje.Un dragón aprende primero a ponerse de pie, luego a golpear sus alas, y finalmente a respirar fuego.El modelo BDH sigue un camino similar – cada etapa de su “vida” trae un tipo diferente de aprendizaje. 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. Si la neurona y neuronas unirlas para reforzar su conexión σ(i, j). i j Por qué creo que el BDH es una evolución, no sólo otro modelo El papel no es sólo teórico, sino que apunta hacia una Ofrece ventajas reales y mensurables. “The Brain-like Dragon Hatchling (BDH)” new direction in AI architecture Transparente e interpretable AI Uno de los mayores puntos de dolor en los LLM modernos es Raramente se sabe BDH cambia eso: sus “sinapses” corresponden directamente a relaciones conceptuales. las conexiones que refuerzan como el modelo “piensa” sobre una idea dada. y (al igual que en el cerebro), lo que hace posible debutar e incluso . opacity por qué Vía sparse positive audit reasoning processes Esto abre la puerta a la IA explicable en ámbitos críticos - medicina, finanzas, derecho - donde la comprensión Un modelo ha llegado a su conclusión es tan importante como la conclusión misma. por qué Aprendizaje en el vuelo (Inference-Time Learning) BDH se aplica incluso durante la inferencia, lo que significa que las conexiones entre las neuronas pueden evolucionar Se adapta al usuario o contexto en tiempo real, desarrollando una forma de que “recorda” ideas a través de tokens y párrafos. Hebbian learning Sin renovación short-term memory ➡️ Esto lleva a los LLM más cerca de - modelos que continúan mejorando la conversación en el medio, como lo hacen los humanos, sin ningún ajuste adicional. lifelong learning Razonamiento estable y escalable a lo largo del tiempo Los transformadores luchan con — una vez que se va más allá de su ventana de contexto entrenado, la coherencia se colapsa. BDH, sin embargo, está diseñado como una Su comportamiento permanece estable a medida que crece la profundidad del razonamiento y el número de neuronas. long-range reasoning scale-free system Esto significa que podemos construir que se ejecutan durante días o incluso semanas —planificación, investigación o simulación— sin perder la coherencia lógica. agentic systems Modelos de fusión sin olvidar catastróficos BDH introduce una propiedad única llamada : dos modelos se pueden "fusionar" simplemente conectando sus gráficos. a diferencia de los transformadores, esto no degrada el rendimiento ni requiere retraining. model merging ➡️ Puede combinar modelos de diferentes dominios (por ejemplo, médicos y legales) sin ajuste. ➡️ Esto abre el camino para , donde los “plugins neurales” reutilizables se pueden conectar como componentes de software. modular AI Desempeño y eficiencia BDH-GPU funciona como un , lo que significa que se puede entrenar de manera eficiente utilizando PyTorch y GPUs. Su parámetro y costos de computación crecen — no exponencialmente como en las grandes pilas de transformadores. state-space system linealidad ➡️ Esto permite construir modelos potentes en , haciendo BDH accesible tanto a investigadores independientes como a startups. 10M–1B parameter range Conexión a la Computación Neuromórfica El BDH se define en términos de y Es una opción perfecta para Los chips como o que emulan redes biológicas directamente en silicio. neurons synapses neuromorphic hardware Loihi TrueNorth ➡️ Esto abre posibilidades para correr En eficiencia energética , plataformas de robótica, o sistemas bio-inspirados. large-scale reasoning models edge devices Un paso hacia la “AI axiomática” Los autores plantean la idea de sistemas cuyo comportamiento no sólo puede ser observado sino Es como descubrir la “termodinámica de la inteligencia”: leyes de escala previsibles y dinámica de razonamiento estable. Axiomatic AI formally predicted over time ➡️ Este punto hacia adecuado para su uso en - De las finanzas y la salud a los transportes. certifiable and safe AI architectures autonomous, high-stakes environments Creación de una red neuronal Para comprender realmente cómo funciona BDH, decidí construir una pequeña prueba de concepto: , entrenado en el problema clásico XOR. (A Rust wrapper alrededor , el núcleo C++ de PyTorch). Este pequeño proyecto fue inspirado por el famoso Pero mi objetivo no era la brevedad, era la claridad.Quise comprender profundamente cómo los mecanismos de BDH podrían funcionar en la práctica. minimal “tiny-BDH” in Rust autograd via tch-rs libtorch Una red neural en 11 líneas de Python El código fuente completo está disponible en mi repo de GitHub , preparado específicamente para este artículo. A continuación, voy a caminar por la implementación paso a paso. Puede parecer verbosa, pero eso es intencional - el objetivo aquí es Para todos aquellos que estén interesados en el BDH. ZhukMax/tiny_bdh_xor maximum transparency and accessibility ZhukMax/tiny_bdh_xor Cargo. toml Este ejemplo está escrito en Empezamos con una archivo: el manifiesto que define el proyecto y sus dependencias. Rust Cargo.toml La dependencia clave es , un envoltorio de Rust seguro alrededor de la biblioteca C++, que potencia PyTorch. nos da acceso a , de , y otras características básicas del aprendizaje profundo directamente de Rust. tch libtorch tensors autograd Porque el BDH utiliza conceptos conocidos como y , tiene sentido reutilizar estas abstracciones existentes en lugar de reimplementarlas desde cero. Nuestro objetivo no es recrear PyTorch - es explorar la de la BDH en la forma más simple posible. neuronas Sinapsis learning logic Aquí está el fragmento 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"] } 💡 La función de descarga-libtorch le dice a Cargo que recupere y conecte automáticamente los binarios de libtorch correctos para su sistema operativo y arquitectura. Sin ella, necesitaría instalar manualmente PyTorch y configurar la variable del entorno LIBTORCH. Con ella, todo "solo funciona" - Cargo descarga y conecta la biblioteca durante la construcción. 💡 La función de descarga-libtorch le dice a Cargo que recupere y conecte automáticamente los binarios de libtorch correctos para su sistema operativo y arquitectura. Sin ella, necesitaría instalar manualmente PyTorch y configurar la variable del entorno LIBTORCH. Con ella, todo "solo funciona" - Cargo descarga y conecta la biblioteca durante la construcción. puede variar dependiendo de su configuración.) (Nota: la versión exacta de tch — The Core of Our Tiny BDH src/main.rs Sitio web / main.rs En los proyectos Rust, todos los archivos fuente viven dentro del En este caso, ya que es una , mantendremos todo en un solo archivo - Vamos a importar las dependencias necesarias y establecer el punto 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(()) } Seleccionar el dispositivo (CPU o GPU) En la línea 6, decidimos para ejecutar los cálculos - en la GPU o CPU: where checks whether CUDA is installed and detects any NVIDIA GPUs. tch::Cuda::is_available() Si CUDA está disponible, el código selecciona la primera GPU: Device::Cuda(0). Si CUDA no está disponible (por ejemplo, en un Mac o un servidor solo de CPU), se configura por defecto en Device::Cpu. La variable Luego se incorporan a otros componentes, como so that son creados y calculados en el mismo dispositivo. dev VarStore::new(dev) all tensors Creación de los datos de formación A continuación, definimos el y tensores para nuestra pequeña red neural XOR — su conjunto de entrenamiento: 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); Comenzamos con una matriz plana de 12 números ( ), describiendo cuatro muestras XOR. Cada triple de números es un ejemplo: 4 × 3 [0, 0, 1] [0, 1, 1] [1, 0, 1] [1, 1, 1] Los dos primeros valores son entradas binarias ( y El tercero es una constante input (always ), ayudando al modelo a separar los datos linealmente. X₁ X₂ bias 1 Después Convertir este plano en una matriz — cuatro muestras, cada una con tres características de entrada. Mueve el tensor al dispositivo seleccionado (GPU o CPU), asegurando que todos los cálculos se realicen en un solo lugar. .reshape([4,3]) 4×3 .to_device(dev) El segundo tenor, Contiene el Para cada entrada: y expected outputs [0], [1], [1], [0] Estos corresponden a la tabla de verdades 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 red 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 - el tamaño del campo neural (número de neuronas en la capa). d = 16 - la dimensión de bajo rango para las matrices E y D, que define cuánto se comprimen y expanden los datos. u = 0,20 - la tasa de olvido para la memoria rápida σ; valores más altos hacen que "olvide" más rápido. hebb_lr = 0,01 - la tasa de aprendizaje para las actualizaciones en hebreo - controla la magnitud en que las nuevas activaciones modifican σ. En BDH, la memoria es representada por una matriz de conexión especial. y temporales No almacena los pesos aprendidos del modelo (estos son manejados por descenso de gradientes). , la formación de asociaciones a corto plazo - una especie de "memoria de trabajo" activa durante la inferencia. Hebbian Memory: σ (sigma) Memoria sináptica which neurons were active together Continuing: smax = 1.0 – limita la fuerza máxima de conexión en σ, evitando los valores de fuga. sparsity_thresh = 5e-3 - elimina elementos σ muy pequeños, manteniendo la memoria escasa y estable. lr = 5e-3 - tasa de aprendizaje para el optimizador Adam que actualiza los parámetros regulares del modelo (E, D, R_in, W_read). pasos = 3000 – número de iteraciones de entrenamiento (cuántas veces el modelo ve los datos). Inicialización de parámetros y el “campo neural” Después de definir nuestros hiperparámetros, creamos una - un contenedor que contiene todos los pesos entrenables y los vicios de la red. Luego añadimos los parámetros aprendibles del modelo - sus "pesos", que se actualizarán durante el entrenamiento: 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 variable define una parte del modelo BDH: r_in - la proyección de entrada en el campo neural. E, Dx, Dy - las transformaciones internas, análogas a los pesos de una capa oculta. Pero recuerda: BDH no tiene capas en el sentido habitual - es más como un campo único de neuronas auto-conectadas. w_read – la proyección de salida, utilizada para leer las activaciones finales de la red. Optimización y memoria rápida A continuación, iniciamos la , una variante popular de descenso de gradientes que ajusta automáticamente las tasas de aprendizaje por parámetro. una plaza matriz llena de zeros. Esto representa la ¿Qué tiendas las conexiones entre las neuronas y se actualiza en cada etapa de entrenamiento. Adam optimizer σ [n × n] fast Hebbian memory temporales 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 - Es decir, durante el pre-entrenamiento offline. egg Forward Pass - El primer vuelo del dragón El siguiente bloque de código realiza el , el paso principal de cálculo donde las entradas se transforman en salidas ( ) de : 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); Aquí está lo que pasa paso a paso: x_neu = x.matmul(&r_in) - los datos de entrada entran en el campo neural. y1 = relu_lowrank_forward(...) — los datos se comprimen, se expanden y pasan a través de una activación de ReLU. (Definiremos esta función de ayuda a continuación.) a = x_neu.matmul(&sigma.T) — recupera la señal adicional de la memoria hebrea σ, basada en asociaciones neuronales temporales. y2 = y1 + a - fusionando la señal "current" con la memoria a corto plazo - esta es la idea central de BDH. z y logits - la proyección final de procesamiento y salida, combinando tanto el conocimiento a corto y largo plazo del modelo. La producción Aún no han pasado por una Ellos representan el antes de la activación – los pensamientos no refinados del dragón antes de tomar forma. logits sigmoid raw predictions Bajo rango + ReLU Helper Como se ha prometido, aquí está el asistente de ReLU que usamos en el paso adelante: /// 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 es un . Instead of a big dense matrix Lo factorizamos como con , de , de . el low-rank linear layer with ReLU W ∈ R^{n×n} W ≈ E · Dᵀ E ∈ R^{n×d} D ∈ R^{n×d} d ≪ n The idea is straightforward: you Proyecto en un espacio latente compacto de tamaño Para pequeñas demostraciones como XOR esto es principalmente ilustrativo; para los modelos a escala GPT, los ahorros de memoria pueden ser (Terabytes en la escala) don’t need all possible synapses d massive La línea 3 comprime el “campo neural” de alta dimensión (n características) en un espacio latente de tamaño d. La siguiente línea la expande de nuevo a n como una combinación lineal de patrones de decodificación de D. Juntos esto actúa como una única multiplicación por W ≈ E · DT, pero utiliza 2nd parámetros en lugar de (n^2). Pérdida, Backprop, paso Ahora añadimos el estándar - Calcular la pérdida, ejecutar el backprop, actualizar los pesos: training step let loss = logits .binary_cross_entropy_with_logits::<Tensor>(&y, None, None, Reduction::Mean); opt.zero_grad(); loss.backward(); opt.step(); Estas cuatro líneas son las : medir error, calcular cómo corregir el modelo, y aplicar la actualización.Después de cada iteración, la red se acerca un poco más a la solución correcta. heart of the training loop Actualización de memoria rápida hebrea (σ) The last part — and really the core BDH twist — is the que corre y mantiene los valores estables: 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); }); Piensa en esto como BDH : se adapta rápidamente al contexto actual (hebreo), gradualmente Los modelos antiguos ( y permanezca (esparsidad) y se mantiene numéricamente (Clamp + normalización de la función) working memory forgets u compact stable Lo que hemos construido Hemos creado una red con la Modos de aprendizaje descritos en el artículo: two Aprendizaje lento - backprop clásico que forma los pesos permanentes (E, D, R_in, W_read). Aprendizaje rápido: actualizaciones en hebreo de la matriz σ durante la inferencia/entrenamiento. intencionalmente La tercera parte - — porque, como señalan los autores, todavía no está completamente especificado.El diseño de ese mecanismo es no trivial y de esta visión general; incluso el artículo de investigación sólo esboza esta dirección a un alto nivel. 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 Como se esperaba, después de unos pocos miles de pasos la red converge ( , de ) y predice XOR correctamente. loss ↓ acc → 1.0 Entrar en la consola Para que la dinámica del entrenamiento y los resultados sean fáciles de inspeccionar, añadamos un poco de madera ligera. 1) Progreso cada 300 pasos Pérdida de impresión y precisión durante el entrenamiento: 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) Predicciones finales Después del entrenamiento, descargue las predicciones del 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) Con vs. sin memoria rápida (σ) Compara predicciones cuando la memoria hebrea es 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 un código de trabajo completo, consulte el repositorio: https://github.com/ZhukMax/tiny_bdh_xor Para un código de trabajo completo, véase el repositorio: https://github.com/ZhukMax/tiny_bdh_xor https://github.com/ZhukMax/tiny_bdh_xor Construir, entrenar y predicir resultados El modelo converge rápidamente, y se puede ver que: Las pruebas (σ = en) son casi perfectas: [~0, 1, 1, ~0]. Preds (σ = off) match — lo que se espera para XOR: es una tarea estática que se puede resolver por los pesos "lentos" sin memoria 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 qué σ no es "necesario" para XOR XOR es una función booleana simple que la red puede aprender con su Los parámetros ( La capa hebrea shines when there’s - secuencias, asociaciones, "lo que sucedió antes" - no cuando cada muestra es independiente. slow E/Dx/Dy/R_in/W_read σ context over time Qué probar al lado de ver σ Pay Off Sequences (memoria de contexto): Predice el símbolo final de un par que apareció anteriormente en la misma secuencia (copia / recuerdo asociativo). Dependencias de largo alcance: tareas de paréntesis equilibradas: compruebe la corrección de la pareja en 20 a 100 pasos. Adaptación en el vuelo: Durante la inferencia, “injecte una nueva regla” (un par de tokens) y verifique que el modelo la utiliza sin actualizaciones de gradientes. σ ablaciones: Compare la velocidad/calidad de convergencia con σ en/de en tareas de predicción más difíciles. Log nnz(σ) y observe cómo las conexiones se fortalecen/destruyen con el tiempo. El incubador de la IA está cerca (conclusiones) BDH no es sólo “otra alternativa a los transformadores”.Es un vistazo a la próxima era de las arquitecturas neuronales – aquellas que En lugar de esperar a que se retraigan o requieran terabytes de datos, BDH se ajusta a sí mismo. En tiempo real. learn not on schedule, but in the moment of action during reasoning Si los transformadores son como “estudiantes” que completaron un curso y ganaron su diploma, entonces BDH es un - recién nacido, explorando el mundo, cometiendo errores, adaptándose y recordando todo lo nuevo que encuentre. dragon hatchling Esta dirección devuelve la IA a su espíritu original: no sólo para calcular probabilidades, sino para . think within context and experience
