I have been reading _The Philosophy of Artificial Intelligence_ and talking
with Rick. I sent Rick a sketch of some ideas that occured to me about how
you would create a Turing machine. He responded that if I am willing to
withstand some criticism, I should forward these ideas to the net.
Well, here are the ideas...
-Shannon
···
------------------------------------------------------------------------
I worked out some of the language implementation concepts that I was
thinking about. I do not know if I put enough on paper for you to glimpse
what I am seeing. Could you tell me if what I say seems reasonable? Or
crucify or whatever...
APPLICATION GOAL:
*****************
Write a program that would cause a computer to respond to questions like a
human would.
GOAL RELATED ISSUES:
********************
1) The language of the computer's responses and questions is built at
run-time, not by the computer's programming. The computer's
programming will have no knowledge of what constitutes language or language
structure.
2) Sentences input to the computer will be considered perceptual inputs
from reality. In other words, a human can test language inputs against
tactile/visual etc. inputs. This program will not simulate these
comparisons. Humans often do not make this test, therefore, I do not think
the computer needs to (right now).
3) Computer responses will be based on previous sentences input to the
computer. In other words, the computer's only knowledge comes from
sentences that are input to it.
IMPLEMENTATION FLOW:
*************************
1) Get input sentence.
2) Determine sentence associations.
3) If sentence associations conflict, then error condition. Else store
associations.
4) Every once in a while, implement an optimizer which will remove
associations that 'dont fit'.
IMPLEMENTATION RELATED ISSUES:
***********************************
1) Sentences input to the computer must be converted into standard
structures. This will happen when input sentences are compared to stored
structures (or stored sentences) to determine structural regularity.
Sentence structure would be determined by words that stay constant in
regular sentence positions. I expect words like a/an/the, at, above, over
etc. and letters like 'ing', 'ish', etc. to be identified as part of
structure.
2) Sentence concepts must be converted into blocks of associated concepts.
This is done by comparing block concepts output from #1 above, with
previous such concepts. In other words, input concepts must be associated
with previous concepts. I expect words such as 'restaurant' will
be associated with 'food', and sentence structures that contain
'has' + 'ed' will be associated with 'previously' or 'yesterday'.
3) All of the concepts in a sentence must be converted into a standard
association. This is done by comparing the concepts output in #2 to stored
associations to determine any regular association. Associations would be
determined by concepts that are regularly associated. I would expect
sentences like 'The kid walked home' to be associated with
'person', 'young', 'school' (maybe), 'strolled', 'daydreamed', 'building',
'house', etc. *Kid* in this instance would not associate with 'goat'
unless at some other time, 'goat' was associated with home.
4) The conceptual block from #3 will be stored in memory.
5) The computer must communicate any errors that occur in #1, #2, and #3
above. This communication will consist of echoing data, or stating similar
sentences, or stating associations, etc. If the next input sentence
lessens the error, then the program will associate its output with the
original input error.
IN PCT TERMS:
**************
loop 1:
------------------------------------------------------------------
controlled variable = The input sentence structure is like a sentence
structure in memory.
perception = sentence input.
reference = structures in memory
comparison = determine if structure is the same as a structure
in memory.
output = if input structure cannot be found in memory,
then add this to memory, and process
according to error condition.
loop 2:
--------------------------------------------------------------------
controlled variable = Must recognize all the concepts in the input
sentence.
perception = a concept in the input sentence.
reference = concepts in memory
comparison = input concepts must be like previous concepts.
output = if an input concept is not found in memory,
then error condition.
loop 3:
--------------------------------------------------------------------
controlled variable = All ideas should be associatable.
perception = The associations invoked by the input sentence.
reference = Current associations in memory.
comparison = Determine if input conflicts with
associations in memory.
output = If there is conflict, then error.
error loop:
----------------------------------------------------------------------
controlled variable = This error should look like previous errors.
perception = The offending sentence or associations.
reference = Previous offending sentences or associations.
comparison = Determine if a 'similar' offending
perception exists.
output = If a previous offense exists, then do what
you did last time, if it worked. If it did not
work, try something else. If Nothing compares
with the current error, then try something random.
optimization loop:
----------------------------------------------------------------------
controlled variable = should not have unnecessary/out of place
associations.
perception = each concept associated with an idea.
reference = the average of the concepts associated with
an idea.
comparison = determine if a concept is like most other concepts
associated with some idea.
output = if a perception does not fit, remove it from the
association.
Some things this program predicts:
-------------------------------------------------------------------------
1) Once an idea is placed in memory, it does not get compared to other
ideas in memory.
2) If idea A is associated with idea B, the only way to remove the
association is to add associations to idea A until the optimizer eventually
removes idea B. However, the new associations must be added so that they
do not directly conflict with idea B.
3) Once an idea is in memory, there is no way to remove it, except through
the step 2. This means that once an idea is in memory, it will always be
in memory. However, it may be more difficult for you to access the idea,
as the number of associated ideas dwindle.
4) Because of step 2, there may be thing A which you feel is associated
with thing B, even though, you do not feel that thing B is associated with
thing A.
5) There are two ways to replace concept A with concept B: i) Add
associations to concept A which are equivalent to what should be associated
with concept B. Eventually the optimizer will cull the associations of A
that do not fit B, and A will be equivalent to B. ii) Associate all new
ideas with B, and eliminate A from old ideas according to step 2 and 3.
6) People with fewer conflicting ideas learn quicker. (i.e. children)
This is because, if idea A and idea B are in memory, then idea C can only
be accepted if it is associated in such a way as to not conflict with A or
B. This is easier to do if A is not in conflict with B.