Boris asked in a comment on the previous post how i could be ignoring learning in my AGI implementations. My caveat was that it was temporary, but of course any implementation without learning isn’t going to be much of an AGI. Still, i believe i have good reasons.
In an early post, i made an analogy with the mazes you find on kids’ place mats in family restaurants. Basically, it’s faster to solve the mazes by making it start at both ends because you get a better idea of the overall structure of the maze. In retrospect it’s a terrible analogy because the mazes are sooooo dead easy, but hopefully you get the point.
And the point is that learning is not all that brains do. Sure, it’s important. But i’d argue that learning in any particular limited field – such as language – is asymptotic. Once you are fluent your brain primarily does inference, at least to do with building sounds into words, and words into concepts. Also, in some athletic situations – imagine getting a breakaway in a soccer game – you go on autopilot and simply act. There’s no point in arguing that the brain isn’t learning in some manner during these times, but hopefully you get the point.
The question was, how does this inference/autopilot work? You could go the full Monty and build a system that is hard-coded with known patterns, and that takes an input, does a future projection, references its action options to determine goal optimization, and performs an action. I contend that this system is difficult enough to build without worrying about learning, which is probably a bigger problem than all of this put together. (Astute readers will note that i left out not only learning to facilitate future projections, but also learning how actions influence the environment to facilitate goal optimization, which are related, but still different things.)
In fact, i went even simpler. I built a hierarchical system that takes Morse code as input. Possible signals are dot, dash, letter space, word space, and all other space. Signals are temporal, and noisy both temporally (the input can speed up and slow down) and spatially (dots and dashes are roughly 0.8 and spaces roughly 0.2, but have overlapping Gaussian distributions), plus i also added deliberate mistakes. I hard-coded patterns into the system that would match on the input and produce an output, say 1 to 5, and send it up the hierarchy. The higher level was hard-coded with letter patterns that would match on the 1 to 5 input sequences and produce a character, say 1 – 50. (26 alpha, 10 numeric, and a bunch of punctuation.) A third level converted letter patterns into words. The words were output as they were recognized.
That’s it. There was no motor planning or actuation. All it did was take an input and produce a future projection at multiple hierarchical levels. It worked pretty well, i have to say, but that wasn’t the goal. The goal was to inform me about what the output of learning should be. Before beginning i didn’t precisely know what a “pattern” was, i.e. the specific software implementation in terms of structure and behaviour. When i was done, i knew what patterns were for inference purposes, which didn’t tell me how to build a learning system but at least placed constraints on the design of such a thing. Plus, i solved a lot of implementation issues around hierarchy communication. Overall i’d call the endeavour a great success, relative to other AGI efforts.
It’s certain that bolting in a learning system will be no simple task, as the hierarchy will then also need to be able to work with patterns that appear, change, and possibly disappear as knowledge builds up. But still, reducing the scope of a vast research problem can only be seen as a good thing.
I’m now planning to do roughly the same with a system capable of actuation. The plan is to use someone else’s architecture, like LIDA or CogPrime, mostly to help educate myself on the details of those efforts.