Искусственные нейросети научились распознавать лица и писать тексты, но до сих пор не умеют учиться на лету. Что если создать ИИ, который адаптируется к новому опыту прямо во время работы — как живое существо?

Менее месяца назад несколько инженеров и ученых (Adrian Kosowski, Przemysław Uznanski, Jan Chorowski, Zuzanna Stamirowska, Michał Bartoszkiewicz) выпустили научную статью по машинному обучению и нейросетям, предложив интересные идеи для изменения существующих архитектур. А говоря проще, они предложили новую архитектуру искусственной нейронной сети.

Это довольно объемная интересная статья с конкретными предложениями по архитектуре сопровождается множеством формул и графиков. Но все же довольно не простая ибо научные работы таковыми и не обязаны быть. Я постарался разобраться и описать простым языком, то есть сделать научно-популярный обзор. Часть терминов, их перевода и аллегорий придуманы мной.

---

Ну, это база (введение)

Представь себе молодого дракончика, который только что вылупился.
Он уже знает, как летать и дышать огнём — но ещё не знает, как реагировать на новые ситуации. Он учится не по книжкам, а по опыту, прямо во время полёта, запоминая, какие действия помогли, а какие нет.

Вот это и есть BDH — Baby Dragon Hatchling, “драконий детёныш” — новый тип нейросети, который объединяет обычное обучение (как у классических сетей) и мгновенное самообучение во время работы.

Нейросеть — это набор нейронов, соединённых «весами», которые обучаются методом градиентного спуска, то есть постепенно корректируют веса, чтобы уменьшить ошибку.

Это как ученик, который после каждой контрольной пересматривает свои ошибки и постепенно становится лучше.Но когда он решает задачу в моменте, он ничего нового не запоминает — всё обучение было заранее.Это «обучение в яйце» — то, что делает обычный трансформер или GPT.

В обычных сетях процесс такой:

1. Обучили модель заранее.

2. Заморозили веса.

3. Теперь она только “вспоминает”, но не “учится”.

? А что делает “драконий детёныш”

Дракончик (BDH) устроен хитрее:

• У него есть постоянная память — как у обычной нейросети (то, чему он научился до вылупления).

• И есть временная память, похожая на инстинкты или короткие связи между мыслями.

Когда он решает задачу, он создаёт новые связи прямо на лету:

если два нейрона активируются вместе — он усиливает между ними связь.

Это называется правило Хебба (Hebbian learning):

“нейроны, которые срабатывают вместе, соединяются сильнее”.

Такие связи хранятся в отдельной матрице σ — как временная карта того, что недавно происходило.
Если ситуация повторится, он вспомнит, “ага, я уже видел это, вот что помогло!”

BDH меняет процесс обучения:

• Он учится во время работы, даже без пересчёта градиентов.

• Он может адаптироваться к новой информации на ходу.

• И всё это — без остановки и без затратных пересчётов, которые в обычных сетях требуют GPU-обучения.

То есть BDH — это нейросеть, которая учится жить, а не просто повторять.

---

Учимся стоять, летать, дышать огнем (этапы обучения)

Авторы статьи описываю два этапа обучения, кратко затрагивая возможность третьей, на мой взгляд очень важной для развития архитектуры BDH.

? I. Обучение “в яйце” — предобучение модели

Это классическая стадия, аналогичная обучению трансформера:

• Модель обучается офлайн на большом корпусе данных (тексты, переводы и т.д.).

• Используется backpropagation, оптимизатор типа AdamW, loss-функция по предсказанию следующего токена.

• На этой стадии BDH формирует свои постоянные веса — “G” (в статье они названы fixed ruleset).
  Они соответствуют тому, что в трансформере было бы параметрами Wq, Wk, Wv, W1, W2 и т.д.

Результат: получается «зрелый детёныш», который уже умеет рассуждать и понимать язык — но без опыта взаимодействия с конкретным пользователем или задачей.

? II. Обучение “во время жизни” — Hebbian / fast-weight обучение

После этого начинается второй тип обучения — “в процессе работы”.

• Во время инференса (чтения/генерации текста) BDH изменяет временные состояния — σ(i,j), “синаптические веса”.

• Это не градиентный спуск, а локальное правило:

  если нейрон i и нейрон j активировались вместе → усиливаем связь σ(i,j)

• Такое обновление реализует Hebbian learning (“нейроны, которые возбуждаются вместе, связываются сильнее”).

• Эти изменения живут только пока идёт диалог или reasoning-сессия — после сброса состояния σ модель возвращается к своим “вылупленным” знаниям.

Результат: BDH способна самообучаться в контексте, усиливая понятия и связи, которые часто встречаются в текущем reasoning‑процессе. Это примерно как человек, который временно запоминает разговор или идею, чтобы использовать её позже в рассуждении.

? III. (Теоретически) третья стадия — “перенос опыта”

В статье об этом говорится вскользь: если Hebbian‑обновления сохранять и усреднять, можно получить нечто вроде долгосрочной памяти, аналог постоянного обновления весов — но пока без точной формулировки алгоритма.

Авторы предполагают, что:

• быстрая память (σ) живёт на масштабе минут/сотен токенов;

• медленная память (G) изменяется реже, на масштабе дней/обновлений модели.

Это открывает путь к lifelong learning — системам, которые обучаются непрерывно, не теряя старых знаний (в отличие от катастрофического забывания трансформеров).

---

Почему я считаю, что это эволюция? (преимущества)

Статья “The Dragon Hatchling (BDH)” — не просто теоретическая работа, а попытка указать новое направление в проектировании ИИ, которое даёт реальные технические преимущества.

Интерпретируемый и “прозрачный” ИИ

Главная боль современных LLM — непредсказуемость: почему модель делает тот или иной вывод, непонятно. BDH меняет это, у неё есть прямое отображение между «синапсами» и понятиями, можно буквально наблюдать, какие связи усиливаются, когда модель «думает» о конкретной идее. Состояния модели разреженные и положительные (как в мозге) — это делает возможным отладку и аудит reasoning‑процессов.

→ появится возможность создавать объяснимые AI‑системы для медицины, финансов, юриспруденции — где нужно понимать «почему» модель что‑то решила.

Обучение “на лету” (inference-time learning)

BDH использует Hebbian learning во время инференса, то есть связи между нейронами могут меняться без дообучения. Это делает возможным самоадаптацию к пользователю или контексту без пересборки весов, встроенную кратковременную память, которая «запоминает» концепты на уровне токенов и абзацев.

→ это приближает LLM к lifelong learning — «учится» в процессе разговора, как человек, без отдельного fine‑tune.

Устойчивое и масштабируемое рассуждение во времени

Трансформеры плохо обобщают рассуждения за пределами контекста, на котором их обучили (проблема «reasoning over long sequences»). BDH строится как scale‑free система — то есть её поведение стабильно при увеличении длины рассуждения и числа нейронов.

→ можно делать агентные системы, работающие неделями (планирование, исследование, симуляции), не теряя когерентности.

Объединение разных моделей без катастрофического забывания

У BDH есть свойство «model merging» — две модели можно «склеить», просто соединяя их графы. Это резко отличается от трансформеров, где объединение весов почти невозможно без деградации.

→ объединение моделей разных доменов (например, медицинской и юридической) без переобучения;
→ модульный AI, где блоки можно подключать как нейронные «плагины».

Производительность и эффективность

BDH‑GPU реализуется как обычная state‑space система, и значит можно обучать её с помощью PyTorch и GPU, количество параметров и вычислений растёт линейно.

→ создание мощных моделей с меньшими затратами (10M–1B параметров), что делает архитектуру доступной для исследователей и стартапов.

Связь с нейроморфными вычислениями

Поскольку BDH естественно описывается через взаимодействие «нейронов» и «синапсов», она готова к переносу на нейроморфные чипы (Loihi, TrueNorth и др.).

→ возможность запускать большие reasoning‑модели на энергоэффективных устройствах (edge AI, робототехника, бионика).

Шаг к “Axiomatic AI”

Авторы предлагают концепт Axiomatic AI — моделей, поведение которых можно не только наблюдать, но и строго предсказать во времени. Это своего рода «законы термодинамики» для ИИ: предсказуемое масштабирование и стабильность reasoning‑поведения.

→ сертифицируемые и безопасные модели, подходящие для автономных систем (финансы, медицина, транспорт).

---

Простая реализация нейронной сети

Я решил сделать очень простую реализацию идей для задачи XOR. Минимальный «tiny‑BDH» на Rust с автоградом через tch‑rs (обёртка над libtorch), вдохновленный статьей с примером кода простой нейросети обратного распределения. Получилось не 11 строк как у автора "A Neural Network in 11 lines of Python", но я ставил задачей разобраться в BDH, а не сделать как можно короче.

Код из статьи полностью можно посмотреть в репозитории ZhukMax/tiny_bdh_xor, который я подготовил специально для статьи. А ниже поясняю его и получается это многословно потому что я пытался когда писал эту статью добиться максимальной прозрачности и доступности изложения.

? Cargo.toml

Так как мой пример на языке Rust, то нам понадобится файл cargo, содержащий информацию о программе и ее зависимостях. tch — это обёртка над C++ библиотекой libtorch, которая является “ядром” PyTorch. Она позволяет использовать тензоры и автодифференцирование из PyTorch напрямую в Rust-коде.

Так как основные принципы нейросетей такие как синапс, нейрон и другие используются и в Дракончике, то смысла писать код их реализующий с нуля нет и можно переиспользовать из существующей libtorch. Тем более что у нас самый что ни на есть простой пример реализации.

Фича download-libtorch говорит Cargo автоматически скачать и подключить бинарники libtorch (для вашей ОС и архитектуры), чтобы не требовалось ставить PyTorch вручную и прописывать пути через LIBTORCH. Иными словами, без этой опции нужно было бы заранее установить libtorch и указать его вручную, а с ней всё подтянется и свяжется автоматически при сборке.

[package]
name = "tiny_bdh_xor"
version = "0.1.0"
edition = "2021"

[dependencies]
anyhow = "1.0.100"
tch = { version = "0.22", features = ["download-libtorch"] }

Примечание: версия tch может отличаться.

? src/main.rs

В папке src должны располагаться все файлы проекта, так как у нас минимальный пример, поэтому весь код разместим в одном основном файле 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(())
}

На шестой строке происходит выбор на каком устройстве выполнять вычисления — на GPU или CPU:

• tch::Cuda::is_available() проверяет, установлена ли CUDA и видит ли библиотека видеокарту NVIDIA.

• Если CUDA есть, выбирается устройство Device::Cuda(0) — первая видеокарта в системе.

• Если CUDA недоступна (например, на Mac или обычном сервере без GPU), используется Device::Cpu.

• Переменная dev потом передаётся в VarStore::new(dev) и другие операции, чтобы все тензоры создавались и считались на одном устройстве.

Далее создаем входные и выходные данные для нашей маленькой нейросети XOR — фактически, это её «обучающий набор»:

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 чисел (4 × 3), который описывает четыре примера для задачи XOR.
Каждая тройка чисел — это один пример:

[0,0,1]  
[0,1,1]  
[1,0,1]  
[1,1,1]

Первые два элемента — бинарные входы (X₁ и X₂), а третий всегда равен 1 и играет роль смещения (bias) — постоянного входа, который помогает модели находить оптимальное разделение данных.

После этого .reshape([4,3]) превращает плоский массив в матрицу 4×3:
4 строки (примеры) × 3 столбца (входные признаки).

Наконец, .to_device(dev) переносит этот тензор на выбранное устройство (GPU или CPU), чтобы все вычисления происходили там же, где и параметры сети.

Второй тензор — это правильные ответы для каждого из четырёх входов:

[0], [1], [1], [0]

Они соответствуют результату логической функции XOR:

• 0 XOR 0 → 0

• 0 XOR 1 → 1

• 1 XOR 0 → 1

• 1 XOR 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: i64 = 64 — размер «нейронного поля», то есть количество нейронов внутри слоя модели.

d: i64 = 16 — низкий ранг матриц E и D; определяет, насколько сильно мы сжимаем данные перед обратным разворачиванием.

u: f64 = 0.20 — коэффициент забывания для быстрой памяти σ: чем больше u, тем быстрее сеть «забывает» старые связи.

hebb_lr: f64 = 0.01 — скорость обновления Hebbian-памяти; регулирует, насколько сильно новые связи влияют на σ.

Hebbian-память

В «Дракончике» (BDH) память — это особая матрица связей σ (сигма), которая работает как временная синаптическая память. Она не хранит веса сети (их обучает градиентный спуск), а запоминает временные связи между активными нейронами в моменте. То есть это те знания, которые нейросеть получает во время работы с пользователем.

smax: f64 = 1.0 — ограничитель максимальной силы связи в σ; предотвращает взрывы значений.

sparsity_thresh: f64 = 5e-3 — порог разрежения: элементы σ с абсолютным значением меньше этого числа обнуляются, что делает память компактнее и стабильнее.

lr: f64 = 5e-3 — learning rate (скорость обучения) для оптимизатора Adam, который обновляет обычные параметры сети (E, D, R_in, W_read).

steps = 3000 — количество итераций обучения; определяет, сколько раз модель увидит данные и обновит свои параметры.

После параметров добавим код создающий хранилище параметров нейросети — место, где будут лежать все обучаемые веса и смещения. И добавляем в это хранилище обучаемые параметры модели — её «веса», которые будут изменяться во время обучения:

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 });

Здесь переменные хранят параметры модели. Все они инициализируются случайно и будут обучаться во время градиентного спуска:

• r_in — вход в нейронное поле,

• E, Dx, Dy — внутренние преобразования (аналог весов скрытого слоя), дело в том, что у Дракончика нет слоев в том смысле, в котором они есть в обычных нейросейтях,

• w_read — выход из поля.

Далее инициализируем оптимизатор Adam — стандартный алгоритм градиентного спуска, который автоматически подбирает шаг обновления для каждого параметра сети. Так же создаем тензор σ — квадратная матрица размером [n × n], заполненная нулями. Это быстрая Hebbian-память модели: в ней хранятся временные связи между нейронами, которые обновляются при каждом шаге обучения.

let mut opt = nn::Adam::default().build(&vs, lr)?;
let mut sigma = Tensor::zeros(&[n, n], (Kind::Float, dev));

for step in 0..steps {
 ...
}

Внутри цикла нужно добавить код для обучения Дракончика когда он еще в "яйце". Следующий фрагмент кода — основной прямой проход (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);

На второй строке происходит сжатие, развертка и активация ReLU. Функцию, которая будет реализовывать эти процессы ReLU мы напишем следующим шагом.

Строки 3 и 4 добавляют к полученному результату добавочный сигнал, полученный из Hebbian-памяти σ. Здесь кроется коренное отличие Дракончика (BDH) от обычных нейросетей.

После того как результату были добавлены сигналы из краткосрочной памяти еще раз прогоняем модель и получаем выходные данные, учитывающие и краткосрочную и длинную память модели. Эти значения (logits) ещё не прошли через sigmoid, но уже отражают предсказание модели до активации.

Как и обещал пишем функцию для ReLU

/// y = ReLU( (x E) D^T )
fn relu_lowrank_forward(x: &Tensor, e: &Tensor, d: &Tensor) -> Tensor {
    let h = x.matmul(e);                       // [B,n]·[n,d] = [B,d]
    h.matmul(&d.transpose(-1, -2)).relu()      // [B,d]·[d,n] = [B,n]
}

Это «тонкий» (low‑rank) линейный слой с ReLU, который заменяет тяжёлую матрицу W ∈ R^{n×n} её факторизацией W ≈ E · Dᵀ, где E ∈ R^{n×d}, D ∈ R^{n×d}, d ≪ n. Смысл в том чтобы не использовать все нейроны и потенциально возможные синапсы, а сократить их до минимально‑необходимого количества. В нашем примере это не играет роли потому что мы создали совсем мало нейронов, но сети на подобии GPT содержат колоссальное кол‑во параметров так что потенциальная экономия памяти может измеряться терабайтами.

Строка 3 сжимаем высокоразмерное «нейронное поле» из n признаков в компактное латентное пространство размерности d. В следующей строке разворачиваем компактное описание обратно в размерность n, но уже как линейную комбинацию «декодерных» паттернов из D. В сумме эти два шага — это эквивалент умножения на одну большую матрицу W ≈ E·Dᵀ, только параметров в разы меньше: 2·n·d вместо n².

Давайте добавим следующий фрагмент кода, который выполняет обратное распространение ошибки и обновление весов — то есть шаг обучения модели:

let loss = logits
  .binary_cross_entropy_with_logits::<Tensor>(&y, None, None, Reduction::Mean);
opt.zero_grad();
loss.backward();
opt.step();

Эти четыре строки — «сердце» цикла обучения. Они измеряют ошибку, вычисляют, как нужно поправить модель, и применяют это изменение. После каждой такой итерации сеть становится чуть ближе к правильному решению.

Остается последняя часть обучения и, в общем-то, основного кода — блок обновления быстрой (Hebbian) памяти σ, он выполняется вне автограда и аккуратно стабилизирует значения:

tch::no_grad(|| {
    let bsz = x.size()[0] as f64;

    // 1) Строим "согласованность" текущих активаций: outer = y2ᵀ @ x_neu
    let outer = y2
        .detach()                  // отрываем от графа, чтобы не шли градиенты
        .transpose(-1, -2)         // [B,n]ᵀ → [n,B]
        .matmul(&x_neu.detach())   // [n,B] @ [B,n] → [n,n]
        .to_kind(Kind::Float)
        * (hebb_lr / bsz);         // масштабир. по размеру батча и шагу Hebb

    // 2) Работаем на временной копии (избегаем move/borrow-проблем)
    let zeros = Tensor::zeros_like(&sigma);
    let mut s = sigma.shallow_clone();

    // 3) Экспоненциальное забывание и добавление свежих связей
    s *= 1.0 - u;                  // "старая" σ затухает (forgetting)
    s += &outer;                   // добавляем новые ко-активации (Hebb)

    // 4) Ограничители, чтобы σ не "взрывалась"
    // изначально я делал без этого ограничителя
    // из-за чего после компиляции, во время обучения программа падала в ошибку
    s = s.clamp(-smax, smax);      // жёсткий клип по модулю

    // 5) Разрежение: мелкие значения обнуляем (экономия и устойчивость)
    let keep = s.abs().ge(sparsity_thresh);
    s = s.where_self(&keep, &zeros);

    // 6) Нормализация по строкам: стабилизируем энергию σ @ 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) Записываем назад в основную σ без изменения владения
    sigma.copy_(&s);
});

Это оперативная память BDH, которая быстро подстраивается под текущий контекст (Hebb), постепенно забывает старое (u), остаётся компактной (sparsity) и численно устойчивой (clamp+нормализация).

Теперь мы реализовали нейросеть с двумя, описанными в статье, типами обучения, оставив за скобками третий шаг — перенос временной памяти в долговременную. На самом деле, я считаю, что решение как реализовывать эту третью форму обучения слишком сложный вопрос, выходящий за рамки этой обзорной статьи. И считаю так на том основании что она даже в научной статье не раскрыта в полной мере.

Как запустить

# 1) Создай проект и вставь файлы
cargo new tiny_bdh_xor && cd tiny_bdh_xor
# (замени Cargo.toml и src/main.rs кодом выше)

cargo run --release

Ожидаемо за пару тысяч шагов сеть сходится (loss ↓, acc → 1.0) и правильно предсказывает XOR.

Вывод данных в консоль (логирование)

Чтобы суметь оценить качество работы получившегося кода и обучения Дракончика предлагаю еще добавить логирование в консоль части данных по мере обучения и теста готовой, прошедшей обучение модели.

Во-первых, добавим вывод качества прогноза каждые 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);
}

Логирование результата предсказания:

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);

Сравним качество предсказания с включенной кратковременной памятью и без нее:

let probs = z.matmul(&w_read).sigmoid();
println!("\nProbs (σ=on):");
probs.print();
println!("Preds (σ=on):");
preds.print();

let y1_nos = relu_lowrank_forward(&x_neu, &e, &dx);
let y2_nos = y1_nos;
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();

Полный код получившегося решения можно найти у меня в репозитории на GitHub: https://github.com/ZhukMax/tiny_bdh_xor

Результаты сборки, обучения и предсказания

Модель сошлась, и видно, что:

• Probs (σ=on) дают почти идеальные вероятности: [~0, 1, 1, ~0].

• Preds (σ=off) совпадают — для 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 — простая булева функция, её легко выучить параметрами E/Dx/Dy/R_in/W_read. Hebbian-слой σ помогает, когда есть контекст/память по шагам (последовательности, ассоциации «что было ранее»), а не когда каждый пример независим.

Что попробовать дальше, чтобы увидеть пользу σ

1. Последовательности (контекстная память): предсказывать последний символ из пары, встречавшейся ранее в той же последовательности (copy/associative recall).

2. Длинные зависимости: скобочная последовательность, проверка парности на расстоянии 20–100 шагов.

3. Адаптация на лету: во время инференса «ввести новое правило» (пару токенов) и проверить, что сеть его использует без дообучения градиентом.

4. Абляции σ: сравнить качество/скорость сходимости σ on/off на более сложных задачах предсказания, логировать nnz(σ) и смотреть, как растут/затухают связи.

Инкубатор ИИ близко (выводы)

BDH — не просто ещё одна “альтернатива трансформеру”. Это намёк на следующую эпоху архитектур, где модель учится не по расписанию, а в момент действия. Она не ждёт переобучения, не требует гигабайт данных, а корректирует себя прямо во время reasoning-процесса.

? Если трансформеры — это “ученики”, прошедшие курс и получившие диплом, то BDH — “дракончик”, который вылупился и сразу пошёл исследовать мир, ошибаясь, адаптируясь и запоминая всё новое, что встречает.

Этот подход возвращает ИИ к тому, что было задумано в самом начале: не просто вычислять вероятности, а мыслить в контексте и опыте.

---

P.S. К сожалению, ничего не написал в статье про свою новую библиотеку EFx для работы с UI в Rust... ну что ж, с следующий раз.