Adaptive learning · TransientAI

Why not just train a model?

The usual pipeline is to pretrain on a very large corpus, post-train, freeze the weights and serve them. Training is an event that happens once, somewhere else, for everyone. That has costs we would like to avoid for a system meant to run on a personal machine:

Facts are learned expensively. One study reports that transformers store roughly 2 bits of knowledge per parameter, and only after seeing a fact on the order of a thousand times (Allen-Zhu and Li). Writing a line to a store takes one step and no gradients.
Updating weights can forget. In one continual-learning test, fine-tuning on new facts reduced performance on old ones sharply, while updating only a few memory slots reduced it far less (sparse memory finetuning). We have not reproduced these figures.
A frozen model cannot learn from you, privately and cheaply, after it ships.

Three levels of adaptation

These are the levels we use to say how far the prototype goes.

Adapting the knowledge. New facts, new words, corrections. baby does this in real time: one new lesson costs about half a millisecond.
Adapting how much and when it learns. Steps per lesson, when to sleep, what to ask, how far to trust a match. Our first versions had these as constants chosen by hand; the move is to make each a quantity the system measures from its own experience. So far: the reliability bar (set from the noise it measures in its own lessons) and how boldly it guesses (set from its own track record). Several others remain constants.
Adapting the learning mechanism itself. For each kind of thing it meets, try different ways of learning it and keep whichever generalises, judged on facts it held back. This is the level that most distinguishes the work, and the one where the prototype is both most interesting and most limited.

What the prototype does at level 3

Given groups of lessons and no instructions, baby chooses per group among remembering, fitting a rule, selecting, searching for a small program, or training a small network. Some outcomes from the synthetic curriculum:

Sums, differences and doubling became rules; "which is bigger" became a selection; multiplication and "how far apart" became programs it built (first × second, first apart second) and that stayed right beyond the numbers it was taught; capitals and colours stayed memorised because nothing could be worked out.
Given a heap of 792 unlabelled lessons, it found 9 units itself (the teacher had named 13; some followed one rule and were merged), with a scorecard identical to the teacher-organised version.
In the invention battery it worked out all 16 hidden numeric kinds nobody wrote a mechanism for, and 7 of 9 harder ones by reusing constants and programs learned from earlier kinds as vocabulary. Taught in the wrong order, the harder ones failed more often (8 of 72), so the gain came from learning and not luck. It explained 0 of 120 unexplainable kinds (random codes, primes) and answered 0 wrongly.
It asks. Where two explanations both fit, it names the number that would tell them apart. With digit sum taught on 0 to 15, one such question took it from 88.9% to 100% of unseen questions; random questions needed three.

Caveat

The limit is large and we want it visible. The mechanisms, the expression language and the thresholds are ours. The system builds and selects inside a language we gave it. Calling that "invention" means expressions and vocabulary, not a new kind of learner. Mechanisms of a different kind, not a formula, are not yet started.

Learning that stays light

Learning should be light enough that nearly anyone can do it, without a data centre. Three things measurably help:

A surprise gate. A lesson the unit can already work out is neither learned from nor stored.
Refit, do not re-decide. A lesson consistent with a settled rule just refits it exactly; the expensive cross-validation of all mechanisms only runs when something structural changed.
Exact where possible. Fitting a rule is solved, not iterated: 392× fewer operations than the 800-pass gradient descent it replaced, for the same rule.

In the scale test, learning one more fact stayed at roughly half a millisecond from 20 to 600 units. More in efficiency

Learning in real time

One advantage we hope to keep is that a user's correction can change behaviour immediately, without a training run. A concrete case: when baby guesses beyond what it was taught and a teacher says it was wrong, it stops guessing in that region right away. Before this was built, after one correction 303 of the 305 other wrong guesses stayed wrong and 2 became wrong facts; after it, none stayed wrong and none became wrong facts (they were all refused). It stops; it does not yet learn the new regime from one point, so the right guesses nearby are refused too. Doing that is on the roadmap.

Vocabulary

These terms are the founder's, used as directions. They may shift.

Adaptive Learning	Learning that goes beyond conventional machine learning: continuous, from interaction, with internals that change, and with a learning process that itself adapts.
Maximization	Optimising a system for the most capability in a given computational space. We report capability against parameters, bytes and estimated joules as separate numbers.
UMA	"Ultragenerative Maximized Architecture": the architecture Transient is aiming at. A bare UMA is the tiny starting unit; a learned UMA has accumulated what it learned. Not yet built.

Next steps on this thread

Run on real data (small factoid and word-problem corpora) to see which of this survives contact with messy text.
Let a correction teach the new regime, not only stop the old guess.
Adapt more of the remaining constants from measurement.
A unit that starts tiny and grows capacity only when it saturates.