It is very pleasant that the topic of artificial intelligence is not stalled, but continues to evolve. There have already been a lot of articles with great ideas and interesting comments. Looking at all this diversity, I wanted to return to the series of publications that had been started six months ago and share some thoughts and arguments that have arisen since then. All this I tried to put together in one big article that describes all aspects of how the final product will work, and contains considerations for its implementation.
The article really turns out great, so I will lay it out in parts. Some are in the process of writing, some are ready. Although it is not a TK, I try to be as constructive as possible, because all this is started for future implementation.
Well, the last thing I wanted to say in this message. For many, the main feature of AI is its unattainability. In order to somehow rely on their objectivity, I will try to further avoid this definition and call it simply a program. Especially since this will be nothing more than a program.
Introduction
Last time we agreed that our creation should correspond to man as much as possible. More specifically, it should be thought of as a person (at a qualitative level). Obviously, to achieve this goal, we will have to understand how we actually think. Then you need to imagine the entire system, divide it into components that can already be implemented in the form of classes, structures, functions and other syntactic structures from programming languages. Such is the general approach in the design of object-oriented systems.
')
To begin with, we will try to find out how the thinking process is going on in our country (here we can include training, decision making, the emergence of an idea, etc.). Strange as it may seem, the first thing to do to solve this problem is to forget that the question of thinking is a secret behind seven seals for science and humanity as a whole. You know, sometimes some facts only interfere in solving the problem.
A well-known example - students in the class were divided into two groups and offered to solve the same problem of medium complexity, but requiring an unusual approach. Then one group was told that “this is a very difficult task, and high-school students could not cope with it,” and another hinted that, supposedly, this “standard” task was taken from the collection of the same “standard” tasks. I think that it is not necessary to talk about which group eventually coped with the task.
In order not to bring here kilobytes of reasoning (of which there is already enough here) and immediately direct the course of your thoughts in the right direction, I will state some points in the form of abstracts, which at this stage should be treated as axioms:
- The thinking process is reduced to working with information: input => filtering => record => storage => search => output (reaction).
- The functions involved at each stage are logically simple (if we consider them at a high level of abstraction), as they are implemented on neurons. From which we can assume that the final product will take up little disk space (I think that the order of a few megabytes is likely even less if you ignore the information stored in memory).
- The whole system will function only when all components are implemented, as they are interconnected. That is, we will have to model some semblance of a virtual organism in order for it to be autonomous and self-sufficient.
Permanent memory
The key point in the entire system is memory. And more specifically, its structure. The idea of ​​a neural network is undeniably tempting, but in this way we have to deal with IBM. To make life easier for us and rid IBM of a competitor, let’s take as a unit of information something more self-sufficient and understandable than a bit or signal level. I even find it difficult to say what to call this unit in one word (can someone tell me?). I can only list examples: a letter, a word, a phrase, a sentence, an arbitrary sequence of any previous elements. For now. We will leave vision and hearing until better times, together with the corresponding units of information.
In order for all the functions outlined in the first axiom to be simple logically, so that there are obvious, it is necessary to optimize memory for them as much as possible. I note that these same functions are nothing more than a generalization of the processes occurring in neurons. With age, these processes do not change and do not become complicated. Roughly speaking, what algorithm was used to search for information from a three-year-old person, by the very same person he passes through a thirty-year-old. And all that has changed during this time is memory.
So memory is not just a file system, but also a kind of programming language. Such complex processes as finding patterns, prediction, induction with deduction, the generation of ideas and others - all this is not some external formations that use files from memory for their work. All of them themselves are part of the memory, a kind of program written in its language.
This language is pretty simple. As mentioned above, the program will consist of logical units - tokens. These units are nodes of a complex network. Connections to other units depart from each node. There can be one, two, five, ten connections, rarely more than ten.
For example, I will give one simple knot - the word apple. Connections to the following nodes may depart from it: fruit, edible, round. Well, more complex: a worm, vitamins, apple, pie, Newton, Sleeping Beauty, the Serpent-tempter. And also: “wash before use”, “if it is too beautiful - it was not without chemistry”. Links to other nodes also go from these nodes and, possibly, from some - feedback links to the apple.
But such a structure is not suitable. After all, the connections are different: geometric shape, edible-inedible, a group of fruits and more complex - various scenes and situations in which an apple appears (this is already from the category of visual information), history and art works, etc. specify the type of connection.
The main task of these types is to determine the content of the node to which the link leads. The definition of what is stored there, in what form and how it can be used.
In order not to complicate your life, we will represent the types of connections by the same logical units of information, the same network nodes, to which we will refer. Thus, the final structure has the form of one large network, each node of which contains links to other nodes. In addition, each such link is in itself connected (represented, associated) with some other logical unit. Definition nodes are not special. They also store links to other sites and are as much a part of the overall network as everyone else. Thus, without exception, all logical units are arranged in the same way.
A very important and useful feature of such a structure is the discreteness of its elements. First, the memory consists of indivisible elements. Secondly, these elements are isolated and can be stored in any order and in any order. They are independent of each other in the sense that each node stores only those links that lead from it. The node does not know anything about the links that point to it. So you can safely edit it, without thinking that the information in others will lose relevance.
This is perhaps something familiar, perhaps a slightly unusual design actually gives you more freedom and allows you to make up laws and rules, logical chains, various models of reasoning and other useful things from the elements of memory. How this is done will be described in the following sections.
RAM
In addition to the permanent memory in psychology emit more short. Also, the contents of the consciousness, the subconscious, and much more are singled out ... In order not to introduce confusion, let us imagine all this as a single and understandable component - operational memory.
Perhaps someone will be surprised - how can such different components be replaced with one single? This question is beyond the scope of this article. Let me just say that it is justified. Toward the end, it will become clear that, nevertheless, in our model of the mind (intellect - it is more convenient for someone), it is possible to find analogues of both short-term memory, consciousness, and subconsciousness, and a whole heap of any tinsel that psychologists distinguish.
But back to the RAM. Although on the one hand it is “operational”, on the other - it is still “memory”. Therefore, it would be logical to organize it in the same way - in the form of a network. And in order to somehow allocate it, you can create one node - “random access memory”. It will contain links to all elements that relate to it.
One of the fundamental differences between the operational memory and the permanent one is that only in the operational part of it all transformations take place - the so-called “thinking process”, everything that relates to it. Constant memory is not editable directly. This can be compared with the version control system: a snapshot (copy) of the desired area of ​​permanent memory is created, then this snapshot undergoes changes, after which the updated copies of the nodes replace their originals.
Now it's time to figure out exactly what changes and transformations will occur in the RAM. Once it consists of nodes, the question boils down to what elementary transformations can be performed with nodes.
- Creation . In fact, there is quite a controversial point. As is known, in a real neural network there initially exist a certain number of nodes, which only decreases with time. But in our system to save resources, nodes will be created as it works. This will occur in two cases: all incoming information will be converted to a mini-network of newly created nodes, and in the process of “thinking” various combinations will be created from copies of already existing nodes (so-called imagination). You can read more about these two processes in the “communication” and “thinking” sections.
- Uninstall . Here the idea is the same as in the garbage collection in .NET or Java. The node that has already worked its and is not needed at the moment is removed from the RAM. Then it is either recorded in the permanent memory, or deleted altogether. It all depends on whether it is associated with existing nodes in the permanent memory. If not, then it is useless and there is no point in writing it down.
- Search The search is used in the “recall” process, so it will be discussed in detail in the appropriate section. Its meaning is to pull out the necessary nodes from the permanent memory into the operational memory. It looks like this - in memory there is a node to which a call arrives with an indication of the type of connection. If there is such a connection, then a copy of the element “at the other end” from the permanent memory is rewritten into RAM. The call comes from another node. The mechanism of these challenges will be discussed in the “motivation and emotions” section. Usually this whole process takes place in an organized manner among several nodes.
- Binding . Linking is used primarily for “learning,” which also received a personal section. In short, for binding, you need at least three nodes and one call. As a result, one becomes the “parent”, the other - the “child”, and the third - the type of connection. As mentioned earlier, all this happens in memory.
Theoretically, these four transformations should be enough. These are elementary operations that occur at the node level. From such operations, more complex functions are formed, which will be described in the following sections.
Subtotal
So what do we have at the moment? I have not in vain compared memory with a programming language. Already a picture of what will happen under the hood of our program emerges. The nodes that are the information carrier, at the same time, interacting with each other in the operational memory, themselves create and rewrite this information - they rewrite each other.
That is, our main goal is the creation of a programming language, one of the features of which will be interpretability and the ability to edit the program on the fly. Probably the definition of "singular programming language" would be appropriate in this case.
So it all comes down to developing the nodes themselves. They will be the building blocks from which all the functions of the system will be built.
That's all for today. Here is an approximate content of the following sections and table of contents in combination:
- Permanent memory
- RAM.
- Motivations and emotions. (Review of the mechanism of calls and something about the integrity of the body)
- Memories. (A rather detailed overview of the use of the search engine)
- Communication (An overview of I / O systems and recognition)
- Training. (A rather detailed overview of the use of the binding mechanism)
- Glimpses of the mind. (Review of the implementation of more complex functions based on elementary transformations)
In addition, a number of ideas were gathered on how to implement some specific functions or components in practice. I do not know yet where to put all this - probably most will find their place in the comments.
PS Artificial intelligence is not a question of philosophy or religion. Asking “what is ii?”, “Does he have a soul?”, “Can he love?” And “will he not enslave the world?”, We are not approaching the solution of the problem. All these questions do not have and cannot have answers, so breaking your head and keyboard keys above them is a waste of time.
Artificial intelligence is a question of the ability to see what is needed and discard all unnecessary.