AGI – To Be or To Emulate?

There is a common mistake being made when developing an AGI (Artificial General Intelligence). Its golden thread is woven through the challenges, through the apparent solutions, and its dark lens taints the thinking of our brilliant minds. It rears its ugly head in our discussions, in our brainstorming and it is preventing our progress in this critical next step for humanity.

When attempting to create a human like AGI, you can go down one of two paths.  (Note:  In the piece I am not discussing ‘non-human intelligences’, I am am only discussing those that purport to be human-like) It is of utmost importance that this is clear before the project begins and it remains clear at every step of the way. Confusing the ultimate goal, at any step of your project, will lead to the failure of your goal. You can try to create a human intelligence, full of complexity, emotions and needs, that is trainable – which develops and acquires the language of its environment. I will refer to this type of project as an AGHI (Artificial General Human Intelligence). Alternatively, you can create a new intelligence (non-human), that ultimately is capable of emulating a human intelligence from an observational standpoint. I will refer to this as AGIHE (Artificial General Intelligence Human Emulator) The distinction between the two is critical, yet the lines are often blurred over the course of a single project. This leads to categorical errors in thought and a hodge podge of code that ultimately ends up sabotaging the end result.

Attempting to create a AGHI
Projects that are claiming to create an artificial general human intelligence are likely NOT creating said intelligence. How can I make such a statement without personally viewing all of these projects? By reading industry texts, academic papers, and investing over 10,000 brain hours to a startup AI company, I have observed critical fallacies in the core and axillary processes. I will cite some simple examples to illuminate some of the stronger problems.

First off, an AGHI needs to be a victim of the human condition. In order for this to occur, it must have a root set of human needs. It must be able to experience these needs, and emotions. For example, it must be able to literally experience pain, or something akin to it. It must be able to experience hunger, to seek out a solution to this feeling of hunger, and to experience satisfaction when the need has been met. This learning, of dealing with the human condition, begins in the womb, and shapes the formation of our neural connections. This is not just a neuron that is turned on or off, for that is just a number and a reference. There is no real feeling associated with a number and a reference. Even a robot, imbued with an AI brain, is not able to actually experience the qualia of pain. It may be able to emulate it, but how can it truly experience it? Pain and hunger happen to be needs that are not even unique to the human condition, yet they are still apart of it. As we can see, this need based system is critical in all “life”. Again, it shapes our development from the moment we are in the womb. It shapes our language acquisition at every step of the way. Early failures will lead to different results than early successes.

It is important to note that the macro process of human development cannot be accurately started and resumed at any arbitrary point. It must begin, at the beginning! A 5 year old human intelligence cannot be created without first going through all the stages that led up to the 5 year old point. Granted, electronically we can speed up the process, but we cannot aim to create an AGHI that begins its life anywhere but conception. We must not cheat the process, for it is the process that yields the results we are after.

Today, as it stands, an AGHI project generally starts by creating a structure of some kind to hold information. This is generally a relational database or a neural-network. A decision is made on an edge based storage system, which focuses on the relationships between neurons, or a node based system, which focuses on the neurons themselves. Some form of an input parser is hard-coded in a programming language and is usually tailored towards the structure and functionality of a base communication language. (English, German, Japanese etc). This parser will likely tokenize the input (break it down into parts) and take a shot at understanding the grammar of the parts. It uses this understanding to extract conceptual and semantic relationships. Input is then filtered, and the sentient details are stored in some format that enables it to be retrieved and used in deeper thinking processes.

The software will likely have a default vocabulary that can grow through observation and use. New words can be acquired. At the current time I write this, there is very limited use of context in industry parsers. I contributed ideas and code as the Manager Of Sentient Intelligence for an AI startup company. While our mistakes were many, at least we utilized context. I implemented a process of context resolution and disambiguation that did not rely on empirical or histographical data. It relied on the context of moment. This process was awarded a patent, thus, in order to honor what is now their IP, I will keep my comments to a minimum on the inner-workings of this process. While this was exciting at the time, the foundational structure and human imposed limitations of our project was bound to sabotage our efforts. Creative differences led to my resignation. I didn’t want to pursue a path that I knew was a dead-end. Needless to say, the company believes otherwise.

Back to it…. some of these AGHIs, with parsers, will also have a limited set of reasoning functions. These are also likely to be hard coded by human programmers. It is important to see what is happening here. As human creators, we see an end result and we try to mimic that end result. We see a human ability to conject new information from existing information, so we envision a way to bestow such an ability onto our AGHI. In doing so, we cheat the process. We code for the end result, and many times we get somewhere that looks a lot like the end result, but in doing so we cut off the greater goal. We realize our goals that were met through hard-coded processes cannot change. They can appear to change, and have some flexibility, but at a deep level, they are static. They cannot truly grow beyond our imposed limitations. The code, and the AGHI are, only what we have created it to be, and as such, the AGHI becomes a poor mirror image of our SELF, not a dynamic representation of human intelligence. An AGHI correctly created would be able to change its way of thinking, just as you may change the way you think. It could acquire new logical processes. It could improve not only its performance but its very processes of thought. The AGHIs we see today are restricted, and even trapped, into a limited paradigm of hard-coded processes. No amount of fancy talk or dreamers hype will change that.

Clearly, this is not a human intelligence, because human intelligence isn’t told how to function. Human intelligence is flexible, it is dynamic, it isn’t bound by faux restrictions of limited if-then code sets (or close derivatives of). If an area of our brain is damaged, another area will try to pick up the slack. If we take a course on English, our English parsing and understanding should increase. A 5 year old literally processes things differently than a 45 year old college professor. It is far more than a larger vocabulary. The understanding of the language and the ability to comprehend is categorically different. A correct AGHI structure would allow for an agent to develop through the same learning curve sets as real humans. Only the time line would be accelerated. These large sets of processes, and functions, some named and known, others unknown, cannot all be accounted for, and coded. We discover more about ourselves as humans today, just as we did yesterday. The architecture has to allow for these same functions to emerge, and grow, and be rewritten, adhoc, even if we, the coders, do not know what that may end up looking like.

It should be clear by now that this isn’t a matter of coding a 100% super bot and then restricting it by age, context or function. For that paradigm would be limiting. Any given human coder is only aware of whatever they are aware of. It surely isn’t the whole of the human condition. If they code the limitations, or better yet, maximum abilities, of the AGHI, then it will be bound in the image of its creator. Any system that attempts to code-to-the-end-result will be left crippled.

It is these various challenges and traps that cause our AGHIs to be coded to the end result. They start off trying to create an artificial general human intelligence, and they end up making compromises in order to incorrectly fulfill end-result goals. At critical stages in the project pet features and functions are emulated, and the hope, or goal, of an artificial general human intelligence is sacrificed at the alter of the coder SELF, corporate imposed time lines, and the pride and ego involved in such an ambitious endeavor.

Attempting to create an Artificial General Intelligence Human Emulator
Most projects that claim to be creating an AGHI are actually creating something more closely resembling an AGIHE. Even then, the lines are crossed at so many points that neither is actually the case.

A real AGIHE would be a new intelligence. It wouldn’t claim to be human, it would claim to be intelligent enough to understand and emulate the human condition. In some respects, this intelligence would be greater than human intelligence to such a degree that it could look down upon the human condition and “act” like us.

The critical flaw in most projects aiming for an AGIHE is once again the penchant to hard-coding to the goal. We, the coder, observe the human condition, and we the coder try to imbue this observation into our AGIHE. Already, we have committed an unforgivable project sin. The AGIHE is supposed to make the decisions upon what it means to be human. It isn’t the coder’s place to tell the AGIHE how to emulate a human, for then it is a human emulating what THEY THINK it is to be human. We will once again will be left with a SELF image that is desperately lacking the understanding required to emulate all human conditions.

An AGIHE needs to have the ability to develop entirely humanly foreign system processes. Just as many machine generated genetic algorithms are hard to understand and read, an AGIHE would likely have internal code, and functions, that human observers wouldn’t be able to understand! So how might a human program code that they don’t understand? That is just it….. the human coder is not to code this. The AGIHE is. They are to provide the architecture that allows for it. A human coder programmed the environment that allowed the genetic algorithm to ultimately come up with code no human could have written. As so, an AGIHE needs to operate under the same mantra. We are to create an environment that allows the AGIHE to develop. We are to create an architecture that is flexible and can be changed. We are to plant the genetic amino acids in the tumultuous and turbulent oceans. Where it can go from there is anyone’s guess. That all depends on the inputs and environment . If it goes the wrong way, kill it. Termination. Reset. Start over. Genetic algorithms take hundreds and thousands of generations to arrive at their solution. Eventually, an AGIHE with the desired abilities will emerge, and it is that AGIHE that will be capable of observing, and eventually emulating the human condition.

It won’t be some AGIHE that is hard-coded to act like an AGHI, because we can’t even get the AGHI right yet, how are we going to correctly hard-code an emulator for it?

Claims of basic A.I.
There are some floating claims around the Internet, and even some projects receiving the Loebner award, of “Artificially Intelligent” systems. The biggest group that comes to mind are the “Chatter bots”.

Online chatter bots are trainable, yet they are clearly not intelligent. In a few sentences of communication with the chatter bot, I am convinced the “I” needs to be dropped from the “AI” tag. At best, these are poor emulations of contextually and topically limited human dialogue. In a real dialogue you have loads of informal logic, you have speaker and listener intent, and you have a constant shuffling of dynamics at play. The chatter bot skips all of this and it merely emulates, albeit poorly, the end result, by an electronic sleight of the hand. Most, if not all, chatter bots, store “triggers” and “responses” and utilize the Chess Master Cheat to trick the observer into believing some actual thought is occurring. Through observation and use they build up these trigger/response lists, so the agent appears to be learning. The Chess Master Cheat is a way to know next to nothing about how to play chess, yet have the ability to beat a chess master at a real game of chess. It is a gamers version of the Chinese Room Experiment. It goes like this:

You, the chess beginner, are about to play two games of chess. Both games are against international Chess Grandmasters. On board 1, you are playing Grandmaster 1. You are the white pieces. On board 2, you are playing Grandmaster 2. You are the black pieces. On board 2, you move second, since you are the black pieces. When Grandmaster 2 opens their game with a move of the white pieces, you mimic that move on board 1, against Grandmaster 1, where you are the white pieces. So your first move as the white pieces on board 1 was really the first move against you one board 2! When Grandmaster 1 responds to your white move by moving the first black piece move, you respond to Grandmaster 2 on board 2 by moving your black piece in the same place Grandmaster 1 moved their black piece. Essentially, you don’t need to know anything about chess. You are taking two games, eliminating the common denominator (you), and effectively pitting your opponent on board 1 vs your opponent on board 2. The worst result you can get (or best, depending on how you look at it) is a tie on both boards. The best result you can get is a loss on one board and a win on the other. You just beat an International Grandmaster at chess.

A chatter bot attempts to utilize this Chess Master Cheat to fool participants into thinking some actual thought is occurring. Within a handful of sentences a user can usually figure out that the chatter bot has no clue as to what is actually going on. There is no context, no deep thought, no new thought, no understanding, and in the end it is a very poor Chinese Room Experiment.

I maintain that a true AGHI or AGIHE will not be created until a project can be committed to doing what it takes. This begins with the architecture. It requires a great amount of thought, yet more importantly, a great amount of restraint. Most of the code written in either an AGHI, or an AGIHE, will be machine-written. Most challenges and roadblocks will be traceable back to a faulty architecture and places where human written code got “too involved” in a process. I purpose that the correct architecture will enable a “fetus” A.I. to be created. A fetus, has very little knowledge. The advanced adult logical processes are yet to be developed. No language is present. A real AGHI or AGIHE will be like a fetus, yet it will have all the abilities to learn and acquire going forward. Too often projects focus on hard-coding the things that need to emerge, and that which should have been coded as an architecture, or core, is left un-addressed. What remains is a system that requires constant tweaking, constant development, constant patches, and it is a perpetual, and poor, reflection….. of the current coder SELF.

Let’s move beyond these limitations. Let us lay down our SELF, and in doing so, lay down some possibly world-changing code that allows for a new intelligence to emerge. When the world is hungry, we can try to feed them, or we can address why they are left hungry to begin with. When someone is repeatedly getting injured, we can try to repeatedly fix them, but we should truly address why they keep getting hurt. The time is now to stop coding the downstream solutions and start addressing what is upstream.

Are we just going to try and code something new that attempts to reach an immediate goal, or can we code something that has the potential to be far greater than our selves?

Previous Post
Leave a comment

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: