Disclaimer: I don't necessarily believe this is a good candidate for building strong(er) AI but it is interesting none-the-less
Also, for here, when I say 'more intelligent' or 'less intelligent' and generally when I talk about intelligence in general I usually mean intelligence in the sense of I know it when I see it[1], and not in any sort of rigorous sense
And another: if I do something that doesn't seem to classify the same as 'normal LW user behavior', please tell me. I find it is quite difficult to course-correct without diving-in, so-to-speak; and so I need as much direct feedback as possible now that I have dived in. I'm feedback hungry. For example, if you thought this post needed more elaboration, or could be shorter or longer, etc that is good information and commentable in my opinion. (meta: my opinion here might also be subjected to this same kind of correction)
Heres the idea: you have a Dumb AI Kernel (DAK) that is essentially an effectively very stupid AI that doesn't have very many abilities and isn't very intelligent at all. Then you provide it with tools[2] that do very particular things, that themselves aren't very intelligent (if at all), that otherwise extend the DAK's abilities, and increase its intelligence. Once composed together, the DAK plus tools are an AI Aggregate (AIA). This may or may not be possible or feasible for making intelligent systems
The idea at a different level is: if you can create a more intelligent AI by providing new modules -- that themselves aren't considered intelligent -- to that AI, then is the reverse true: can you remove modules and make a less intelligent, but still intelligent, AI? And if so, the DAK is the smallest AI that is still an AI, once all other intelligence-increasing modules have been removed. Removing anything else will make the DAK no longer intelligent, or no longer functional altogether
Related to this, you can imagine a superintelligent AI in the future creating temporary mesa-optimizers, and budding off smaller sub-AIs to tackle particular problems. At what point can you have an AI that is actually really stupid do the exact same thing?
Here are a bunch of assorted questions related to DAKs and AIAs:
So far, I am imagining a DAK like how some psychologists believe storytelling is a fundamental form of human thought: everything gets passed through the DAK. Consequently, a DAK reinterprets all of the data it sees to match its internal functionality, despite how simple that functionality is, and inevitably every potentially superintelligent decision it makes is colored by that functionality
An example of tool composition is like: the DAK queries an associative database tool (which just has simple query and append interfaces) using an object Q, the result R is handled superficially in the same way by the DAK and is used as input to a spacial path-finding tool which returns a path object P, then P is sent (by the DAK) into a output device[10] control tool which returns P': a slightly modified version of P representing the active state of navigation along the planned route, and so on. I imagine objects like P would be used instead of persistent internal states within each tool, but it seems much more intuitive to have each tool have an internal state
Some other interesting, but not necessarily functional or useful, ideas similar to this:
An opposite idea to a DAK / AIA might be called something like a Smart AI Monolith (SAM), or something. This would / may look like a bunch of highly-coupled modules whose individual, internal behaviors are highly correlated with one-another. This isn't necessarily a more or less likely-to-work architecture than the AIA architecture, but it certainly is a much more likely-to-be-used architecture because of the lack of composability / modularity of ANNs, and the requirement the entire ANN be correlated / trained all at once, which appears to eliminate any possible composability (I also write about this in just a moment)
The most prominent AI success in recent years was GPT-3 which operates exclusively on text. More recently, we saw OpenAI move into creating combined text and image models with their DALL-E model. Similarly, more and more research is being written related to ANN models which combine multiple types of data, especially for the purposes of generating one type of data (like images) from another (text)
This makes a lot of sense. Consider: GPT-3 used most / all of the text on the regular internet in training. GPT-4 would use all of it, and require even more to train well. But a hypothetical GPT-N that can consume and produce images, audio, text, etc would have a much larger training database to pull from. And having mostly orthogonal modules each for different types of inputs before they reach wherever they are combined internally is likely necessary for such a system. It could be that such a system with adapters from each type of input data to internal data could benefit from the modularity of those adapters. And I mean that in the sense of: can I add / remove this module and have the system still function?
Imagine: a system that can compose multiple input streams, and produce multiple output streams, depending on what functional modules are actually connected to it. Like: a future AI consultant for a company walks / rolls / beams into their server room and connects to a specialized interface with the company servers that gives information from across the company related to whatever it's doing, and allows the AI to perform what it needs to perform in a way that is more highly correlated with its internal function to some degree
But composability and modularity isn't something that comes easily, or at all to ANNs (the SOTA architecture apparently closest to strong AI right now) in particular, and retraining the entire system whenever a new module is attached or reattached is probably very untenable. But if a core subsystem is trained to be able to use external modules like tools, and the external modules are individually trained (or are untrained) to do whatever they do (generate an image from text, transcribe languages to other languages, etc), then the core subsystem could potentially react and understand when a new module is attached, and what to do with it, without needing to be retrained
Composability of ANNs in particular for me is almost verging on a holy-grail for ANN architecture. Having highly composeable ANN modules that are effectively plug and play, and modularity even just in terms of training: where you can train section of your model separately from other sections; would probably allow much, much larger models, and potentially much shorter training times. I suspect it would be like going from analog computers to networked, digital computers. I have worked on topics related to this some and have gotten some positive results. Though there is a lot of work still to be done. I will post what I've found / what I think related to this, if people want me to
Intelligence is quite difficult to define. I have found that a I know it when I see it definition isn't satisfying but is quite helpful for getting defining it out of the way. I have been trying to pioneer this concept which I call a semantic domain, and such domains' semantics (which is a slight overloading of the term 'semantics'), and in this case intelligence has human internal semantics primarily and poor human communication semantics. I may write and describe semantic domains and this overloaded semantics in another post. Regardless, there are certain concepts like this: that are apparently best defined or described with 'I know it when I see it'. Like the color red, for example: it doesn't seem to be best defined as a particular wavelength, or by describing it in terms of red objects, but like: "you have to experience it, but when you do: you know it when you see it" ↩︎
Tools in this document are equivalent to self-contained modules with a simple-enough interface, and hopefully with low / nonexistent coupling to the DAK ↩︎
In the sorta-same sense as with linearity in mathematics: two functional modules A, B are orthogonal if the functionality of B isn't reproducible in any way by the functionality of A, and visa-versa. In general I mean it more like: B's functionality cannot be produced easily by A's functionality. eg: a dedicated FEM solver, and a solver for linear systems are orthogonal because one (mostly) cannot reproduce the other ↩︎
I mean interface in the sense of object oriented programming's interfaces. Like: a well-defined set of patterns that other objects can use to interact with that thing. Think: user interface. When I talk about modules that usually means: as-defined black boxes that have some interfaces that are used for interaction with those modules ↩︎
Datapaths: paths data take through the system by being copied into new memory locations, used as parameters in functions, and being handed off between functional modules ↩︎
For example, the behavior 'writing' apparently involves lots of different functionalities in humans, like: remembering what you wrote, and where; knowing the language you're writing in; knowing what sequences of words look right, and which look wrong; making decision about what to immediately write, about what to write at longer time-scales, and making plans to write those things; converting plans to actions that are mutually consistent; mapping general concepts at a large scale down to actionable representations; accessing experiences and memories in a coherent-enough way that they can be converted into words; expanding high level behaviors into sequences of muscle movements, contextualized by hand position, eye orientation, etc; and remembering all of the tiny details that go into all of these things. These sub-behaviors can presumably be decomposed into the same mostly-orthogonal modules used to build an AIA ↩︎
I generally consider nonpreferential access to (all?) internal data / state as if it was external data, and processing such data just as external data is processed, a likely candidate for how introspection may work internally ↩︎
Good old fashioned AI / symbolic AI. Despite falling out of favor, it may have an important place in future strong(er) AI systems. It could also conceivably be used to create a strong AI all by itself, though it would obviously have to be developed more (and the related unknown unknowns and known unknowns discovered and resolved) to get to that point ↩︎
This must be the most horrible question I keep coming across ↩︎
I generally stick to the definitions that: input devices are the things that create data, and input data is exposed on simple interfaces, probably as a set of tensors; while output devices are parameterized by output data that control how the output devices are actuated ↩︎