Click below to go directly to a specific section:
Failure-Driven Learning | Learning by being Told | Learning by Exploration |
Printed References | Acknowledgments

Artificial Intelligence (AI) is a way for computers to attempt to mimic human intelligence. This page will discuss three ways an AI learns. One way is through failure-driven learning. The second is learning by being told. And the third is learning by exploration.

Failure-Driven Learning



Failure-driven learning is based on creating a program that will learn by making mistakes and then finding a solution so that mistake doesn't happen again. This is similar to the way humans learn. If we make a mistake we usually try to learn from that mistake to improve upon ourselves so we don't make it again.

The above animation shows a graphical representation of a program that has to put the "a" block on top of the "b" block. At first the program can't because the "c" block is on top of the "a" block. The program now has to figure a solution to why it can't lift the "a" block. It devises a solution to move the "c" block off the "a" block. Once the "c" has been moved, it can now place the "a" block on top of the "b" block and its objective is completed.

sample code to do this would be:
(in the examples below x is block "a", y is block "b", and z is block "c" or any block that is on top of the block being moved)
original code: (to-do ?task (achieve (on ?x ?y))
       (move ?x ?y))
program-altered code: (to-do ?task (achieve (on ?x ?y))
        (prog (for-each ?z (on ?z ?x)
                        (get-rid-of ?z))
                 (move ?x ?y)))

The "program-altered code" is code that the program created so it could remove any blocks on top of the block that it was originally supposed to move.

The problem with the above example is that the program can not necessarily know why it can't lift block "a." It could just have another box on top of it, be glued to the ground, or both. It would need some way of determining the physical situation of block "a." This would fall into the are of induction (not discussed here).

Learning by being told



Learning by being told is another area of AI learning. It's simply interaction of a teacher (human) and the AI student. The teacher is there to teach the AI how to do things in the real world. Because the teacher has a grasp on the real world situation, it virtually elimates the need for induction by the AI. The only problem is communication between the teacher and the AI. Preferably the teacher would want to teach in english, but the AI doesn't understand english. There isn't a sufficient english to code translator around.

One solution is for the teacher to use partial english. This reduces the need to interpret unnecessary parts of the sentence such as some pronouncs and articles.

i.e. Instead of saying "It's easier to move the little boxes first" the teacher could say "move little boxes first."

This reduces the command down to a verb, adjective, noun, and word telling the program in what order to move the boxes.

Another solution is for the teacher to actually put the instructions into code. This is not preferable since many reasons for AI is to get it to interpret english commands, sometimes on the fly. Short instructions are no problem to put into code but should the instruction set be lengthy, the teacher will spend a lot of time coding the instructions, instruction by instruction, until the AI understands the way the teacher is teaching it. This can be time consuming. Especially if the AI doesn't learn it, or learns it incorrectly and new instructions need to be created to nullify what it has learned.

Learning by Exploration



Learning by exploration is a little different than the other ways of learning. The purpose of learning to explore is to just gather information, and not really pursue a goal. All it tries to do is find interesting information so it can store and learn from it. But it doesn't explore until it has nothing left to explore. It will follow a series of tasks. It will perform one task, which may add more tasks, and then move onto the next task. This causes a database of concepts to continue to grow.

The program will organize the tasks in order of "interstingness." And it will also not always look at each task. Sometimes it need to determine what would be a waste of time exploring. This causes a problem because it needs some way of determining what task is worth exploring, and should it choose not to explore a task make sure it's not missing out on anything by ignoring it.

Sometimes the program will find that the tasks it has left are not interesting enough to explore. If this happens it will go through all its tasks and explore a "suggestions" slot so it can make the tasks more interesting. This way the program will more than likely not run out of tasks to explore.

The program should also be able to generate concepts from what it already conatins in it's database. This way it can generate more tasks to explore or just create new concepts that may have purpose in the real world.

Printed References

  1. Eugene, Charniak / McDermott, Drew (1985). Introduction to Artificial Intelligence. Addison Wesley
  2. Tanimoto, Steven L. (1995, 1990). The Elements of Artificial Intelligence Using Common Lisp. W.H Freeman and Company

Acknowledgments


The Introduction to Artificial Intelligence book by Charniak and McDermott provided a majority of the information for this web page. We found it to be the best source that we could find to provide information on the topics discussed, primarily "failure-driven learning" and "by being told learning."

The animated image above, under the Failure-driven learning title, was created by David Holmes based on a picture in the above book, that we expanded upon.