Intelligent Systems And Their Societies Walter Fritz

Results And Experiments

 

The GL can learn a few words in any human language; we have tried English, Spanish, German and French. It can learn to draw geometrical figures and simple pictures. It can learn the concepts of amount (two lines, five curves) and it can learn simple arithmetic, expressed in any language. It can learn to make abstractions and finally it can learn simple board games.

Let's see some examples. We use English below, but the other languages work as well. At the left we show the input from the person and at the right the output of the General Learner. Between each input/output pair there is a NEW START (that cleans the screen), that we do not show. (Note: The GL started with an empty memory. "R" stands for RETURN and "E" stands for ENTER. The user's typing is in bold and comments are in italics).

 

Numbers And Shapes

(Person typing)
draw me two circles R
-- On the screen appears a window stating --
"I do not know what to do."
Since the GL at this point has an empty memory; it cannot know what to answer.
circles E
-- Person draws three circles with the mouse -- E
At this point the GL has created a number of concepts and also a response rule:

concept 10005
Type: WORD
(this indicates that the concept contains characters)
*pAddrP: circles
(the contents of a pointer to the location where the characters "circles" are stored)
*pAddrRs: -10002
(the contents of a pointer containing the number of the response rule in which the concept occurs in the situation side)
The other parts of the concept are empty.

concept 10006
Type: DRWG
(this indicates that the concept contains a drawing)
*pAddrT: 10007 10008 10009
(the three composite concepts that use the concept 10006)
*pAddrP: 2 0 0 0 -18
(2 is line thickness, then come x and y location and then 0 for delta x and -18 for delta y. The -18 indicates that the circle was drawn with -18 in the y dimension.)
The other parts of the concept are empty.

concept 10007
Type: OBJ
(this indicates the concept is an object, having location and speed)
*pAddrT: 10010
(the composite concept that uses the concept 10007)
*pAddrP: 30 0 0 0 10006
(30 is the x location, 0 is the y location, the next two zeros are horizontal and vertical speed and 10006 is the corresponding drawing)
The other parts of the concept are empty.

concepts 10008 and 10009 are very similar to 10007.

concept 10010
Type: COMB
(this indicates the concept is a composite)
*pAddrP: 10007 10008 10009
(The three objects that are part of the concept)
*pAddrRr: -10002
(the response rule in which the concept occurs in the response side)
The other parts of the concept are empty.

response rule -10002
From: LEARNEDRULE
(indicates the function that created the response rule)
LastUse: 124
(the instant it was last used)
*pAddrS: 10005
(the concept of the situation side of the rule)
*pAddrW: 15
(weight of the concept of the situation part)
*pAddrR: 10010
(concepts of the response side of the rule)
Now we enter:
draw me three circles R
the same three circles appear on the screen
Of the input, the GL understands only the word "circles".

Now we will teach it the concept "two", so we can later ask it to draw "two circles."

two lines E
-- the person draws two short vertical lines -- E

two lines E
-- the person draws two long horizontal lines on the left side of the screen -- E

two curves E
-- the person draws two small curves with wide (bold) trace. This is done with the menu and the mouse -- E

SLEEP Here the program enters the sleep mode.
We have used the word "two" in three different circumstances. We used always the same amount of drawings but varied the location, the type of drawing, small and long, vertical and horizontal to avoid that the GL creates incorrect concepts. Still we may have drawn only on the upper part of the screen. The GL may have created a concept "two" that means "high on the screen". We can best correct this type of error by reinforcement learning. When the GL uses the word incorrectly we indicate our disapproval by command - down arrow. This changes the weights of the response rule that the GL used, for instance from the initial value of 15 down to 5.
Now we enter:
draw me two circles R
-- the GL draws two circles ff--
Now it answers correctly.

Going further:

triangle E
-- the person draws a triangle -- E
draw me two triangle R -- the GL draws two triangles --
Since the GL now knows "two" and "triangle", it can respond correctly. Note that it does not take into account "draw"" and  me". Also at this point it cannot respond to "triangles" (the word in plural form).


 

The GL Learns To Greet

(Person typing)
i am carl R
-- On the screen appears a window stating --
"I do not know what to do"
i am walt E
hi walt E

i am pete E
hi pete E

i am george E
hi gorge E

SLEEP Here the program enters the sleep mode.
Now we try again:
i am carl R
hi carl

The GL has successfully learned how to greet.

 

The GL Learns Some Math
To teach the GL arithmetic we first have to teach it a few more numbers. Thus, similarly to the way we taught it the concept of "two" we teach the concepts of "five" and "one". (We do not show the details). Note though that instead of the word "five" we could just as well teach it the character "5" or the word "cinco" (or even the nonsense character string "asdfjkl;") or the same concept in any other language or notation.

We will now teach it subtraction (""less").

five lines less one line E
-- person draws four small, narrow lines -- E

two lines less one line E
-- draws one long line -- E

five curves less one curve E
-- draws four bold curves -- E

SLEEP Here the program enters the sleep mode. At this point the GL generates a new rule pattern relating the amount rule patterns for "two" and "one":
rule pattern 20009
Type: PAT_OP
(the type of rule pattern that indicates how to read ContP)
Lab2Type: COMB
(the type of the second concept connected by this rule pattern)
LastUse: 133
(the instant it was last used)
wt: 20
(a weight from -99 to +99)
Take2: 1
(the first concept of the response side was taken for comparisons)
Det2: 1
(the concept itself was taken, and not some part of the concept)
Lab1: 10086
(this is the label of the concept for "less". The GL assigns labels from 10001 on. It gives each new concept that occurs the next number as a label)
ContP: 78
(the content of this rule pattern is subtraction)
*pAddrRs: empty
(not used in situation part of any response rule rule)
Now we try again:
draw me five lines less two lines R
the GL draws correctly, three lines
The GL has used the new rule pattern for relating "five" and "two". It has used this rule pattern on an existing response rule: "five lines ->  (drawing of five lines)" modified it, and drawn three lines.

Similarly, we could teach it addition, multiplication, or division by giving three examples each and then letting it SLEEP.

Now we will teach it the concept of "big".

rectangle E
-- person draws a small rectangle -- E

big curve E
-- person draws a big bold curve -- E

big line E
-- person draws a big line -- E

big lines E
-- person draws two big lines -- E

SLEEP Here the program enters the sleep mode.
Now we try:
draw a big rectangle R
the GL draws it correctly
draw a big triangle the GL draws it correctly

 

The GL Learns Some Basics of "Games"
As the last of the examples, let's look at a session of tic-tac-toe.

First we teach it the elements used during the game:

ttt-grid E(the drawing, the "board" on which to play)
-- the person draws a grid of two vertical and two horizontal lines -- E

ttt-cross E
-- the person draws a small cross -- E

ttt-circle E
-- the person draws a small circle -- E

the GL just sits back and
absorbs some new learning

Now we teach it the start up response rule:

the person types ttt-grid R the GL draws the grid
(person points with mouse to the left) and types ttt-cross R the GL draws the cross at the left of the grid
(person points with mouse to the right) and ttt-circle R the GL draws a circle at the right of the grid
OPTION ENTER
(to indicate that all shown on the screen is the action)
let's play tic-tac-toe E
(the present situation)
The GL has now created a response rule with "let's play tic-tac-toe" as the present situation part and all the figures on the screen as the response part.

And on to a game ...

NEW START
let's play tic-tac-toe R The GL shows on the screen the grid, cross and circle.
-- The person chooses "copy, move" from the menu. This changes the pointer into a pair of pliers. --
--The person presses ENTER and moves the cross to a convenient place within the grid E. -- The first ENTER indicated that this is the situation to which the GL has to learn a response. The second ENTER (E) completes the response rule

In the same way many moves are made and the game is played many times. The computer learns specific concrete response rules (not the rules of the game, but pairs of situation -> response). During the sleep period the GL abstracts and generalizes these response rules. The GL can now respond to many situations not met before.

For continuous reading, like a book - continue here
Jump to the top of this document / General Learner / Artificial IS / e-book Contents.


Last Edited 6 Mar. 06 / Walter Fritz
Copyright © New Horizons Press