Seeing 'Mini-AGI' and '8GB VRAM' in the same sentence is a breath of fresh air. Maybe local AGI isn't so far-fetched.

Nobody will throw rocks, I think most people are curious/suspicious about the big players and wants more hands-on since we suspect that this all will come down in cost soon enough.

I also like how it is very organic. It naturally grows and deletes unused elements, so in addition to traditional backprop there is also a natural selection happening in the background. Each new expert has 16 parents by the way, lol.

It doesn't show any indications of solving catastrophic forgetting.

throwing crumpled paper ball

What kind of hardware are you using for training?

nm, I found it:

RTX 3070 Laptop GPU with 8 GB

Super impressive.

Seems a bit premature to make an HN post about then, imho.

It's an interesting idea, but it doesn't really do anything interesting yet. I looked at the output in the training run and it is a far, far cry from intelligence. Worse than GPT-2 as it stands.

I do hope it will perform well when scaled and trained, though; best of luck.

THANK YOU SO MUCH. This is the missing piece.

It interleaves random streams of 32K characters long each when reading the whole corpus, but each such stream reads continuously as you would expect. This is a necessary step to prevent just normal, not catastrophic, forgetting. I have not tested it in any other regimes yet with bigger or smaller windows. You can imagine a person that changes the activity from time to time, so I think it is justified. So there is not really "early in the stream".

What I did test though is reading 524K characters of chess data only and see how other domains have degraded. The results are in the readme under "How continual learning works" section. Spoiler: it just barely degraded the performance.

This is the first thing I see in my life that really looks like proto-AGI, it deserves its name.

Do you find all your own (human) trained knowledge unreliable?

Thanks, it seems like a nice way to compare effectiveness of different non-typical methods which are not yet capable of some more ambitious benchmarks.

This is slop. 8M parameter dense model with context length 64 that you train on enwik9 in 2h will have 1.15 bpb. This model has 1.8 (bits per byte, lower is better).

Making model to consists of many small modules is inefficient on GPU, especially as routing adds data dependencies, etc, and especially with pytorch (compared to a custom kernel).

The difference might be smaller on a CPU which has limited parallelism.

But it's basically equivalent to a very deep model which might be problematic for training.

Indeed this is wasting HN time.

"The model reads 524,000 characters of chess". This is 100KByte of training data in a toy model with rigid parameters and no global learning. Gap with real LLM and trillions of tokens.

This model really addresses the problem of preserving previously learned knowledge, but by restricting the LR of the trunk it stops acquiring new knowledge. Details: "Rethinking the Stability-Plasticity Trade-off in Continual Learning from an Architectural Perspective"

For sure. As it will pass through the whole corpus I will share the weights, run it through established benchmarks for small models and share all of this as an update. I am also planning on making a Youtube video explaining in detail how it works on a deeper level and the whole reasoning behind why it is built the way it is. But no promises here.

The expert swapping architecture is very nice. Have you considered doing nested reinforcement learning where you use the nesting as a sort of low pass filter?

The concept is as follows: You train a critic to mimic the datastream and then you train against the critic instead of training against the data. The idea behind this is that the critic will memorize the training data so you do not need to store the full training data anymore. One of the biggest issues with current online stochastic gradient descent is that it is inherently a memory-less technique where the training data acts as the memory.

You can spin this further by going deeper with the nesting and then dropping the supervised critic. I forgot how to put it in words but the goal is that by having a model train against a critic of the critic, you can then drop the top level critic and instead use the mid level critic itself as your meta learning objective to train the actor against an unlabeled data stream.

Top level critic: learns to mimic the labeled training data via online SGD, then you add a simple hand written loss function to compare the predicted output with a given input. Basically you build a model specifically for distillation. Mid level critic: learns a reward function that mimics the top level critic directly but only gets to see the unlabeled training data and the result of the top level critic. Actor: The actor is exclusively trained against the mid level critic

Through this concept you end up with the existing training data stored as objective inside the mid level critic so you end up training not only against the latest data but also the already memorized data which should lower catastrophic forgetting. Of course at some point you might need to update the mid level critic again and to avoid that you might get away with just adding a very very wide Linear RNN / State Space Model / Mamba / Gated Delta Net as the middle critic (shower thought: use internal RNN states to represent LoRA vectors).

Interesting. I wonder how much could be gained from using tokenization, which makes the model work at a semantic level rather than a syntactic level? I think it’s a force multiplier, but idk if it works here.

I have no practical means of scaling it up at any compatible scale. I will not make any money on it either way as well. So there is absolutely no reason for hoarding it. And as I said I did use Claude in the process, so Anthropic already has full access to it anyway and could steal it just as easily if they really want to.

I also doubt it is really that valuable on the OpenAI/Anthropic scale, at the same time if people will use it and it will work for them on the personal scale it is already a major win for me. New ideas and optimizations I could never have thought of might bring this up from a toy model to an actually useful model trained locally. Then people could add RL and RLHF and other cool things to it to make it even better.

Some OpenClaw/Hermes-like agents actually work like that. (Can't find the link right now.)

I wish I could understand what a single graph in that nice graphic of graphs meant. No explanation for any vertical or horizontal axis. Looks pretty though.

I have not looked carefully but it seems like this is over-promising on avoiding catastrophic forgetting.

The "trunk learning rate" is set at 0.1x the learning rate for the experts, so learning on different subjects disproportionately happens in the experts, and the trunk portion is comparatively more stable. But the population of experts can grow and shrink:

The pool grows when it is short of capacity and shrinks when parts of it stop being asked for.

So:

- doesn't the trunk then _eventually_ still undergo catastrophic forgetting, it just may take much longer?

- and before that point, catastrophic forgetting happens in stepwise chunks whenever the expert pool shrinks?

This is an interesting approach. First of all, thanks for sharing your work. I've done. I want to say similar work in that I have trained continuous learning models and I have also offloaded parametric knowledge to hard drive people underestimate how difficult that is to do in a functional model. I look forward to digging in deeper.

I love the approach of this but "It has to not forget. A model that learns continually and overwrites itself is worse than one that does not learn at all."

Is highly misguided.

While the platonic ideal of Lt Commander Data is appealing, The parable of funes the memorious (Jorge Luis Borges) comes to mind.