DEV Community: Maksim Sekretov

ML без магии: одна Tiny Language Model, одна команда Node.js и все веса на виду

Maksim Sekretov — Sun, 26 Jul 2026 13:22:07 +0000

English version | Русская версия

Tokenization → embeddings → causal Transformer → LM head → softmax → loss → backpropagation. Без TensorFlow, PyTorch и скрытого autograd.

Репозиторий: tiny-language-model-neuro-js.

Большинство объяснений language model показывает правильные формулы, но прячет путь между ними внутри фреймворка. Мне хотелось обратного: один маленький сценарий, в котором виден каждый скаляр, а терминал прямо показывает неправильные ответы до обучения и правильные после него.

Теперь в проекте одна команда:

node src/train.js --generalize --adaptive-teach

Нужен Node.js 18.19+. Зависимостей нет.

Реальный фрагмент из logs/training-log.txt: матрицы AFTER и DELTA одного FFN-слоя:

Сначала результат

Модель получает вопросы сразу после случайной инициализации:

BEFORE TRAINING — random, usually wrong answers
> can human read ?
  model:    ? <unk> ...
  expected: human can read.  [WRONG]

> can fish swim ?
  model:    ? <unk> ...
  expected: fish can swim.   [WRONG]

> can cat read ?
  model:    ? <unk> ...
  expected: cat cannot read. [WRONG]

После pre-training, SFT и adaptive SFT та же модель отвечает:

FINAL ANSWERS AFTER ADAPTIVE SFT
> can human read ?
  model:    human can read.  [CORRECT]
> can fish swim ?
  model:    fish can swim.   [CORRECT]
> can bird fly ?
  model:    bird can fly.    [CORRECT]
> can cat read ?
  model:    cat cannot read. [CORRECT]

Rehearsal controls preserved: 14/14.
Stable criterion reached 11 times in a row.

Начальный текст меняется из-за случайных весов. Итоговый критерий строгий: все ответы должны быть правильными, вероятность каждого target-токена должна составлять минимум 95%, а полная проверка обязана пройти более десяти раз подряд.

Что осталось после удаления лишних режимов

Раньше код содержал несколько режимов отладки и обучения. Они помогали во время экспериментов, но закрывали главную мысль. В итоговой версии остался один pipeline:

текст → word tokenization → token IDs
      → token + position embeddings
      → два causal Transformer-блока
         → multi-head self-attention
         → FFN с двумя скрытыми слоями
      → LM head → softmax → вероятности следующего токена
      → cross-entropy → backpropagation → Adam

Теперь train.js читается как одна история, а не как маленький CLI-фреймворк.

Скаляр создаёт вычислительный граф

Каждое число, участвующее в обучении, является объектом Value:

class Value {
  constructor(data, children = [], backward = () => {}) {
    this.data = data;
    this.grad = 0;
    this.children = children;
    this._backward = backward;
  }
}

Для умножения:

y = a × b
dy/da = b
dy/db = a

Операция запоминает локальные производные. backward() строит топологический порядок графа и применяет chain rule от итогового loss назад к embeddings и весам.

Нейрон — буквально объект

Формула нейрона не спрятана за tensor API:

output = activation(sum(input[i] × weight[i]) + bias)

Реализация повторяет формулу:

forward(input) {
  let output = sum(
    input.map((value, i) => value.mul(this.weights[i]))
  );

  if (this.useBias) output = output.add(this.bias);
  if (this.activation === 'relu') return output.relu();
  return output;
}

Linear — просто массив нейронов, получающих один вход. Это медленнее матричного умножения, зато каждый вычислительный шаг можно увидеть.

Embeddings и порядок слов

Каждый token ID выбирает обучаемый вектор:

token representation = tokenEmbedding[id] + positionEmbedding[position]

Сначала embeddings содержат случайные числа. Полезные связи появляются только потому, что градиенты многократно изменяют эти числа в учебных контекстах. У cat, read или cannot нет вручную заданного свойства meaning.

Self-attention без сокращений

Для каждого токена:

Q = X × Wq
K = X × Wk
V = X × Wv

score = dot(Q, K) / sqrt(headSize)
attention = softmax(score)
output = attention × V

Цикл работает только при past <= position. Это causal mask: модель видит текущий токен и историю, но никогда не получает будущий target.

После attention каждый токен проходит через FFN с двумя скрытыми слоями:

dModel → hidden ReLU → hidden ReLU → dModel

LayerNorm и residual paths окружают attention и FFN.

Полный шаг обучения

Самый важный код проекта занимает несколько строк:

function learnOneToken({ model, optimizer, input, targetId }) {
  const loss = model.loss(input, targetId);

  optimizer.zeroGrad();
  loss.backward();
  optimizer.step();

  return loss.data;
}

Loss — обычная next-token cross-entropy:

loss = -log(P(target | предыдущие токены))

Если вероятность правильного токена мала, loss велик. Backpropagation вычисляет dLoss/dWeight, Adam изменяет параметры, а следующий forward pass возвращает уже другое распределение.

Этап 1: pre-training

Маленький мир содержит 14 связей способностей:

human can read .
fish can swim .
bird can fly .
dog cannot read .

Связь cat + read намеренно отсутствует. Pre-training выбирает позиции из этого текста и учится предсказывать следующий токен.

Этап 2: SFT

Те же связи превращаются в 42 пары prompt-answer:

can fish swim ?
is fish able to swim ?
does fish know how to swim ?

В SFT loss участвуют только токены ответа. На каждой эпохе реализация проходит каждую пару и каждую позицию ответа, поэтому цикл остаётся детерминированным и понятным.

Этап 3: adaptive SFT

Недостающий ответ представлен только target-токенами:

['cat', 'cannot', 'read', '.']

Эти targets получают шесть вариантов вопроса. Это прямое supervision: модель не открыла зоологический факт самостоятельно. Учитель передал факт через loss, а backpropagation распределил информацию по embeddings, attention, FFN, LayerNorm и LM head.

Почему не остановиться после одного правильного ответа? Потому что одна генерация может быть неустойчивой. Цикл продолжается, пока вероятность каждого target-токена не превысит 95%, а вся проверка не завершится успешно 11 раз подряд.

Catastrophic forgetting и rehearsal

Первая реализация обучала только шесть новых вопросов про кошку. Новый ответ она запомнила, но прежнее поведение разрушилось:

can human read ? → cat cannot read.
can fish swim ?  → cat cannot read.

Это catastrophic forgetting в миниатюре. Исправление — rehearsal: adaptive-эпохи повторяют ещё и 14 старых примеров can ... ?. Финальный критерий проверяет одновременно новые и старые ответы, поэтому модель не может закончить обучение, просто заменив всё одним ответом.

Лог создаётся всегда

Команда автоматически записывает:

logs/training-log.txt

Это последовательная ASCII-схема, а не сырой JSON-дамп. Сначала в ней идут все
события forward/loss/backward/update, затем полные матрицы в трёх контрольных
точках:

начальные случайные матрицы
        |
        v
матрицы после pre-training + SFT
        |
        v
финальные матрицы после adaptive SFT

Для каждого перехода лог печатает AFTER-матрицу и точную DELTA-матрицу.
Строки Linear-слоёв подписаны как neuron[n], столбцы — как weight[n],
а bias показан рядом со своим нейроном. Отдельно отмечается самое сильное
изменение в формате слой / нейрон / вес: before -> after -> delta.

Насколько это близко к production LLM

Архитектура и правило обучения настоящие, масштаб намеренно маленький.

Эта модель	Production model
24 word-токена	Большой subword/byte-level словарь
2 160 параметров	Миллионы или миллиарды
Два Transformer-блока	Десятки или сотни
Скалярный JavaScript-граф	Батчевый тензорный граф на ускорителях
Маленький структурированный корпус	Огромные подготовленные datasets
Узкое обученное поведение	Широкий язык и reasoning

Проект не конкурирует с GPT. Это causal language model, уменьшенная до размера, при котором весь путь помещается в одном репозитории и одной мысленной модели:

токен → embedding → attention → FFN → probability
      → loss → gradient → новый вес → изменившийся ответ

Именно этот путь здесь важен. Когда он виден целиком, фреймворки перестают казаться магией: они выполняют те же классы операций в масштабе и со скоростью, от которых эта скалярная реализация намеренно отказалась.

Репозиторий: tiny-language-model-neuro-js.

Автор: Максим Секретов.

ML Without Magic: Building a Tiny Language Model in Pure Node.js and Watching Every Weight Change

Maksim Sekretov — Sat, 25 Jul 2026 09:34:59 +0000

English Version | Русская версия

Tokenization → embeddings → causal Transformer → LM head → softmax → loss → backpropagation. No TensorFlow, no PyTorch, and no hidden autograd.

Repository: tiny-language-model-neuro-js.

Most explanations of language models present correct formulas but hide the path between them inside a framework. I wanted the opposite: one small scenario where every scalar is visible and where the terminal clearly shows incorrect answers before learning and correct answers after it.

The project now has one command:

node src/train.js --generalize --adaptive-teach

It requires Node.js 18.19+ and has no dependencies.

A real excerpt from logs/training-log.txt, showing the AFTER and DELTA matrices for one FFN layer:

The result first

The model is queried immediately after random initialization:

BEFORE TRAINING — random, usually wrong answers
> can human read ?
  model:    ? <unk> ...
  expected: human can read.  [WRONG]

> can fish swim ?
  model:    ? <unk> ...
  expected: fish can swim.   [WRONG]

> can cat read ?
  model:    ? <unk> ...
  expected: cat cannot read. [WRONG]

After pre-training, SFT, and adaptive SFT, the same model produces:

FINAL ANSWERS AFTER ADAPTIVE SFT
> can human read ?
  model:    human can read.  [CORRECT]
> can fish swim ?
  model:    fish can swim.   [CORRECT]
> can bird fly ?
  model:    bird can fly.    [CORRECT]
> can cat read ?
  model:    cat cannot read. [CORRECT]

Rehearsal controls preserved: 14/14.
Stable criterion reached 11 times in a row.

The initial text varies because initialization is random. The final acceptance criterion does not: all answers must be correct, every target token must have at least 95% probability, and the complete check must pass more than ten times consecutively.

What remains after removing the extra modes

The code previously contained several debug and training modes. They were useful while experimenting but obscured the main idea. The final version keeps one educational pipeline:

text → word tokenization → token IDs
     → token + position embeddings
     → two causal Transformer blocks
        → multi-head self-attention
        → two-hidden-layer FFN
     → LM head → softmax → next-token probabilities
     → cross-entropy → backpropagation → Adam

train.js now reads as one story rather than a command-line framework.

A scalar builds the computation graph

Every number participating in learning is a Value:

class Value {
  constructor(data, children = [], backward = () => {}) {
    this.data = data;
    this.grad = 0;
    this.children = children;
    this._backward = backward;
  }
}

For multiplication:

y = a × b
dy/da = b
dy/db = a

The operation stores these local derivatives. backward() sorts the graph topologically and applies the chain rule from the final loss back to embeddings and weights.

A neuron is literally an object

The neuron formula is not hidden behind a tensor API:

output = activation(sum(input[i] × weight[i]) + bias)

Its implementation follows the formula:

forward(input) {
  let output = sum(
    input.map((value, i) => value.mul(this.weights[i]))
  );

  if (this.useBias) output = output.add(this.bias);
  if (this.activation === 'relu') return output.relu();
  return output;
}

A Linear layer is just an array of neurons receiving the same input. This is slower than matrix multiplication but far easier to inspect.

Embeddings and order

Each token ID selects one trainable vector:

token representation = tokenEmbedding[id] + positionEmbedding[position]

Embeddings contain random values initially. They acquire useful relations only because gradients repeatedly change them in training contexts. No meaning property is assigned to cat, read, or cannot.

Self-attention without shorthand

For every token:

Q = X × Wq
K = X × Wk
V = X × Wv

score = dot(Q, K) / sqrt(headSize)
attention = softmax(score)
output = attention × V

The implementation loops only while past <= position. That is the causal mask: the model can attend to the current token and its history but never to a future target.

After attention, every token passes through a two-hidden-layer feed-forward network:

dModel → hidden ReLU → hidden ReLU → dModel

LayerNorm and residual paths preserve stable information flow around attention and FFN.

The complete learning step

The most important code in the project is only a few lines:

function learnOneToken({ model, optimizer, input, targetId }) {
  const loss = model.loss(input, targetId);

  optimizer.zeroGrad();
  loss.backward();
  optimizer.step();

  return loss.data;
}

The loss is ordinary next-token cross-entropy:

loss = -log(P(target | previous tokens))

If the correct token has low probability, loss is large. Backpropagation computes dLoss/dWeight; Adam changes each parameter; the next forward pass gives a different distribution.

Phase 1: pre-training

The tiny world contains 14 ability relations:

human can read .
fish can swim .
bird can fly .
dog cannot read .

The cat + read relation is missing deliberately. Pre-training samples positions from this text and learns ordinary next-token prediction.

Phase 2: SFT

The same relations are converted into 42 prompt-answer examples:

can fish swim ?
is fish able to swim ?
does fish know how to swim ?

Only answer tokens contribute to SFT loss. The implementation visits every pair and every answer position on each epoch, making the training loop deterministic and readable.

Phase 3: adaptive SFT

The missing answer is represented only by target tokens:

['cat', 'cannot', 'read', '.']

Six question variants receive those targets. This is direct supervision: the model did not discover a zoological fact on its own. The teacher introduced the fact through loss, and backpropagation distributed that information across embeddings, attention, FFN, LayerNorm, and the LM head.

Why not stop after one correct answer? Because one generation can be fragile. The loop continues until every target token exceeds 95% probability and the whole evaluation succeeds 11 times in a row.

Catastrophic forgetting and rehearsal

An early implementation trained only the six new cat prompts. It successfully learned the new answer and destroyed old behavior:

can human read ? → cat cannot read.
can fish swim ?  → cat cannot read.

That is catastrophic forgetting in miniature. The fix is rehearsal: adaptive epochs also repeat the 14 older can ... ? examples. The final criterion evaluates both new and old examples, so training cannot finish by overwriting everything with one response.

The log is always written

The command automatically creates:

logs/training-log.txt

It is a sequential ASCII diagram rather than a raw JSON dump. It includes every
forward/loss/backward/update event, followed by the complete matrices at three
checkpoints:

initial random matrices
        |
        v
matrices after pre-training + SFT
        |
        v
final matrices after adaptive SFT

For every transition, the log prints the AFTER matrix and its exact DELTA matrix.
Linear rows are named neuron[n], columns are named weight[n], and biases
are shown beside their neuron. It also points out the largest concrete change as
layer / neuron / weight: before -> after -> delta.

How close is it to a production LLM?

The architecture and learning rule are real; the scale is intentionally tiny.

This model	Production model
24 word tokens	Large subword/byte vocabulary
2,160 parameters	Millions or billions
Two Transformer blocks	Tens or hundreds
Scalar JavaScript graph	Batched tensor graph on accelerators
Small structured corpus	Massive curated datasets
Narrow trained behavior	Broad language and reasoning

The project is not a GPT competitor. It is a causal language model reduced until the complete path fits in one repository and one mental model:

token → embedding → attention → FFN → probability
      → loss → gradient → updated weight → changed answer

That path is the point. Once it is visible, frameworks stop looking magical: they execute the same classes of operations at a scale and speed this scalar implementation deliberately avoids.

Repository: tiny-language-model-neuro-js.

Author: Maksim Sekretov.
: