Hands On: Wilf’s Programmers’ Workshop

Wilf’s
Programmers’ Workshop
Learn more about artificial intelligence techniques in the second part of
Wilf Hey’s investigation into expert programs.

magine training your to build a program that simulates Imagine that you are provided with a

I computer to
recognise concepts
rather than objects.
Last month we built an expert program,
which was able to classify objects. When
enough information was classified our
expert was then able to use tree-
structured data to determine which of
several objects you meant when you
answered relevant questions.
Given enough objects, along with
questions that distinguish them, the expert
can quickly identify anything previously
encountered. A competent computerised
doctor can be built in a similar manner,
asking a patient questions about disease
symptoms, leading to a useful diagnosis.
It is a totally different matter, however,
some of the workings of the
human mind. There are several
reasons why this is a very difficult
task – first of all because we still know
comparatively little about the way our
minds work, and second because the
hardware in our brain functions in very
different ways from computers.
Calling a spade a spade
Consider how you might provide your PC
with the knowledge of what a spade is. You
could, for example, organise this
knowledge with last month’s program in the
form of probing questions – ‘Does it have a
handle?’ – Yes; ‘Does it have a flat metal
blade?’ and so on. However, this hardly
matches the way a human being thinks.
photograph, and you are required to
identify whether the object portrayed is a
spade. If you can record the steps in your
thought process, you should be able to
convert them into program code – at least
in theory.
One of the major problems in education
is that sometimes the experts don’t know
what it is that makes them experts. For
example, the coach who looks for new
recruits for football may swear that he has
an eye for a good player before even
seeing a demonstration of that player’s
football skills.
It may seem unlikely that such
expertise could be transferred to a
computer – it is intangible and undefined.
Yet statistical methods can be used that

Steady as she goes

ne of the things that a man-like computer
Yet it must be sensitive to significant changes.
O mind has to be able to do is identify the
How can it make a judgement of this type?
likelihood that things will continue as they have Let’s look at a simplified version of this
in the past. For example, the software that autopilot problem: our program should monitor a
controls an autopilot needs to recognise that single type of event and warn us when a change
there is some variation in the conditions that is greater than one might expect. Let’s say it will
affect it: wind speed and direction are not look at weather, with a view of deciding if it is
constant, for example. changeable or not.
When there is little change, the autopilot We can first of all define our limits of change:
should not be making tiny, costly adjustments. if it rained yesterday, there is a 75 per cent
chance of raining today; if it
was dry yesterday, there is an
80 per cent chance of a dry
day today.
We can readily create a
history of the last few days,
and note how often the
status changes from wet to
dry or vice versa. If it changes
from wet to dry more than
once in four instances, this is
more than our 75 per cent
impetus factor, so the
program can comment that
the weather is indeed
changeable. It can decide the
same when it sees more than
Many events – like wet and dry days – tend to occur in
one change of dry to wet
unbroken strings, and the likelihood of two consecutive wet within five days.
days can be expressed by a value called the ‘impetus factor’. What is the likelihood that
it is a wet day? You may think that this depends
on whether it was wet yesterday, but the
surprising fact is that we don’t need to know
previous weather if we are armed with both the
wet and dry impetus factors. The chance of today
being wet is actually the sum of two factors:
1. The chance that it was wet yesterday
multiplied by the ‘stay wet’ impetus factor (75
per cent).
2. The chance that it was dry yesterday multiplied
by the ‘become wet’ impetus factor (20 per cent).
If we symbolise the likelihood that yesterday
was wet as W, then the likelihood that yesterday
was dry is (1 – W). Now the likelihood that it was
wet yesterday is really the same as the likelihood
that it is wet on any day; so using a simple bit of
algebra we can combine this information:
W = (W x 0.75) + ((1 – W) x 0.20)
This produces a result of W equal to about 44.4
per cent as the chance of any being wet. So we
have a very useful result: the likelihood of any
particular day being wet is 44.4 per cent.
The SuperCD/Disk contains the QBasic program
IMPETUS.BAS which allows you to calculate this
(and related) values. You can investigate its
simple code to see how it makes conclusions
about the probability of experiencing three days
of sunshine, for example.

308 PC Plus July 1996


Triage
ne of the most useful applications of
O expert machine technology is triage – a
word borrowed from the French for separating
urgent or complex cases from simple ones. You
use triage yourself when you do a quick
classification of mail, putting aside envelopes
that look like bills for opening last.
Sometimes you may be mistaken in a
judgement, but even this rough sorting speeds
up processing. Of course, you won’t rely solely
on this method – it is only a starting point, and
errors in classification can be corrected when
you actually open the envelopes.
In wartime hospitals and other emergency
situations, triage is used to divide the injuries
most urgently in need of attention from the
more routine. Skilled businessmen use triage to
organise their schedules to make the most
effective use of their time.
Expert machines are especially useful for
performing triage, identifying cases that may
require special attention, while dealing with the
more direct, simpler ones. An expert
will fairly quickly convey sufficient
information into an expert program so that
it can establish its own credentials as an
expert. Often the program’s powers will
exceed those of the original human expert.
How can this possibly be so?
Well, besides its inherent speed and
accuracy, the expert program can take the
opportunity to work out precise details of
what the expert only knows instinctively.
The football coach may be making his
selections on a combination of features,
some of which may not even appear to be
relevant, such as size of ears.
Provided with enough examples of the
coach’s decisions, an expert program can
analyse exactly what the coach’s mind
knows only on an unconscious level. The
human coach will continue to make
occasional errors, being not really aware of
how the judgements are made, but the
expert program he or she has trained will
operate flawlessly, effectively aware of the
hidden factor.
Statistics can become complex and
tiresome to a human being, but computers
are good at juggling figures. Using
statistical methods similar to those
employed in the program IMPETUS.BAS
(see the panel on the left Steady as she
goes) an expert program can classify the
information it gleans from sample expert
decisions, and from this create powerful
predictive calculations.
For example, fed the vital statistics
about both champion and hopeless
basketball players, it would not take long
for the computer to discover that
champions are most often rather tall.
Though this may appear obvious to virtually
any human, even without the labour of
calculation, consider that subtle and
interlocking factors may be involved with
more complex tasks.
Hands On: Wilf’s Programmers’ Workshop
diagnostician can be used in a doctor’s waiting
room, for example, to ask sufficient questions
to verify that the patient has only a simple cold
and not a ruptured appendix.
Yet expert machines need not be limited to
triage; any information that can be absorbed
and applied by a human can be incorporated
(with a little effort) into a program. Will we see
autodocs – robot physicians performing life-
preserving surgery – in our lifetime? We already
commit our lives to autopilots, which
incorporate much of the same decision-making
software technology.
The program STUDENT.BAS demonstrates
how triage can be performed by a computer:
samples are divided into two categories, and
corrections are made to the rules until the
program has become expert in its predictions.
After this point, the program can be used to
perform whatever triage is needed, separating
real cases (not samples) into one category or
another, such as ‘superficial wound’ or ‘serious
attention needed’.
Teaching value judgment
A simple but useful job that we may like a
computer to perform is to identify whether
a particular person is an ally – a person
whom we will allow to look at our files and
bypass our computer lockouts. Such a
guardian may be set up with a
comprehensive database recording
personal details of each ally, but this is no
expert – it is a dumb servant.
What we require is a program that will
enable our computer to make intelligent
decisions about a person, to establish
whether the person is an ally rather than to
‘know’ it from a database.
How would you train a human to
function in this role? Simple – you would
outline to the person various criteria: an ally
would be an adult rather than a child; an ally
would wear a uniform, or otherwise use an
identity card with the company’s logo on it;
The flow of logic in STUDENT.BAS is simple: the program evaluates its observations,
formulates an educated guess, and then adjusts its rules whenever it has guessed incorrectly.
and perhaps several other details would
come to mind.
Believe it or not, these sort of criteria –
and even several more vague – can
become part of an expert program’s
memory. In this month’s SuperDisk/CD
project we have built a simplified version of
such a program – one that you will have to
train yourself.
After it has gone through a training
process, STUDENT.BAS (a QBasic
program) will faithfully apply the criteria it
has learnt. This simple implementation
does not record its findings in a file, though
it would be easy to do if you adopt it as a
basis for your own expert machine. In
effect, each time you run it, Student starts
off as an imbecile. See the panel How to
teach your Student on page 310 to learn
how to turn this ignoramus into an expert.
Once you have familiarised yourself
with the program, you may wish to make
changes to it so that it can selectively
reload its hard-earned knowledge. You will
need to save the contents of the Rule and
Tweak$ arrays (evaluations and the
condition names), plus Limit (the number of
rules/conditions), PosResult$ and
NegResult$ (the two categories).
Program details
Student is a fairly simple program which
can be improved in a variety of ways, as
you desire. Here are a few interesting
techniques that we have highlighted from
the source code.
We permit the specification of up to 99
variables (observations) in Tweak$. This is
arbitrary; we can easily change it. In simpler
forms of Basic (for example GW-Basic) this
would be more complex.
Instead of a FOR..NEXT loop we use
DO UNTIL..LOOP so that we can change
the loop variable to its maximum value (99
in this case) when we want to finish the
loop prematurely.
Student works by presenting ➜ p310
July 1996 PC Plus 309
 Hands On: Wilf’s Programmers’ Workshop

How to teach your Student

his month’s project program (on the The more observations (that is, questions asked)
T SuperDisk/CD) is STUDENT.BAS, a QBasic or
the more expert the program will eventually
QuickBasic program that will learn how to make
become, because distinctions between creatures
distinctions between many sample objects. can be more easily made. For example, if you only
You can, for example, educate it in the fine art
ask about whether the creature has a caudal fin
of telling the difference between an aquaticand eats fish, the expert will be pretty limited
mammal (such as a whale, walrus, porpoise, indeed and unable to distinguish between a shark
manatee) and a fish. To do so we don’t even have
and a porpoise.
to tell it the features it should look for – we will
When you have established the various
simply answer its questions about each creature,
observations to be made, you should leave the
and tell it whether it is a fish or a mammal.
next one blank. The program will then be primed
When you run Student you will be asked to to learn from you. It will ask for samples, and
supply names for the Positive and Negative request that you answer a simple Y or N (for Yes
results (which could be ‘Mammal’ and ‘Fish’ or No) to establish the presence or absence of
respectively) and then to supply up to 99 each of the observations.
observations you would want to make. When all the questions about a particular
sample have been
asked, the program will
venture a guess at the
result, and ask you to
mark this with Y or N as
well. If it has guessed
incorrectly (and you
have answered N) then
it will learn from its
mistake and modify its
rules. Note that after
each guess Student will
print a line of
diagnostic information:
this is the status of its
various rules, each with
a value of 1, –1 or 0.
The result will
become more and more
an educated guess, and
STUDENT.BAS is a program that learns from its mistakes, learning
how to distinguish between as many samples as you want, dividing you may eventually
them into two categories. decide that the
program has become more or less an expert on
identifying whether a particular sea creature is
a mammal or not.
You can actually use the diagnostic line to test
Student’s knowledge. Currently it thinks that a
sea-going mammal may have a caudal fin, eats
fish and has a voice; it has decided that it may
not have scales and it has not decided about the
possession of a tail or scales.
When enough varied samples have been seen,
Student may come to the conclusion that the
diagnostic line (quoting the values of the rules it
has deduced) should be 1, 0, -1, 0, 0, 1 – some
whales, for example, do not eat fish. Note that if
the ‘scales’ criterion had become -1, it would
mean that a fish must have scales – which of
course is not true.
It is important to remember that Student is
not learning anything when its guesses are
correct – it learns only from its mistakes.
When the tutor of this program decides that it
has become expert enough and is no longer
having to adjust its rules, Student is ready to
graduate. A few more changes to the program
can turn it into a resident genius, able to sort real
items into the two categories you have set. Those
criteria that have a final value of 0 need not even
be asked – they are irrelevant. The other criteria
throw the balance in favour of the positive or
negative result (one category or the other).
As well as remembering the rules and criteria
names (by storing them as files on disk) the
changed version of Student would have to know
that it is no longer learning, but expounding. You
could include a simple switch for this purpose
(also written to disk), which when set would not
ask for evaluation of each result, nor modify the
rules further.

each of the criteria stored in Tweak$ and
asking you whether the object currently
being evaluated matches it (Y or N). In the
array named Value, 1 is used to indicate Y,
or 0 for N.
In the array called Rules you’ll find a
sequence of values which indicate the
significance of the corresponding question
in Tweak$: 0 means that the rule provides
no clue to the final result; 1 means that the
rule is considered to be a clue towards a
positive decision; and –1 means that the
rule is considered to be a clue towards a
negative decision.
When we multiply each answer value
by the corresponding rule value, we arrive
at several small positive or negative values,
each contributing a particle of information
about whether the sample object deserves
to be in one category or the other.
All these clues are added together. If
the sum is positive, the program guesses
that the positive category (whatever it is
named) is correct; if the sum is negative, it
suggests the negative category’s name.
If the calculation provides the wrong
result for a particular sample, the rules are
modified – the place where this happens is
indicated by a comment in the program
code. Note the use of the SGN function:
Rule(i) = SGN(Rule(i) + Value(i))
SGN always produces a value of 1, –1 or 0,
so it is ideal for our circumstances. We
never want the magnitude to exceed one
(whether positive or negative).
If we omitted this function, the
magnitude of each rule may become quite
large, depending on how many adjustments
to the rules are made. It would then take
many samples to make an effective change
to the evaluation.
Remember that when Student makes
its guesses, it does so only on the basis of
whether its calculation is positive or
negative and not on the magnitude of the
value. The program learns more quickly
when you keep these values low – close to
zero – so that they can change from
positive to negative readily (or vice versa).
This modification of the rules by adding
or subtracting the corresponding answer
values, according to whether the program’s
incorrect guess was Y or N, modifies those
rules where you answered Y.
Assuming that you set up enough rules
to distinguish between objects with
accuracy, and that you gave truthful
answers, the rule values will eventually
settle into the pattern of answers which
always give the correct guess. The best
way to understand this is to watch it
happen – set up a simple three-rule test
and watch what happens to the diagnostic
line. Try it in situations where all questions
are significant, and where one question
has no significance (for example, colour
when trying to distinguish between plants
and animals).
Note that rules which at one point have
a value of 0 (having no bearing on the
answer) may well end up with a different
result after evaluating several more
samples, so even these seemingly
irrelevant questions are still asked while
the program is in its learning mode.
If you use this program as a basis for
your own expert, you will of course stop
asking such insignificant questions (those
with the matching rule entry having a value
0) when the program is switched into
expounding mode. See also the panel
above, How to teach your Student, for
more information.
Keep these projects to hand – last
month’s expert programs, and this month’s
Student program – because in the future
we will return to the topic of expert
systems. These both provide a good
foundation on which to build. PCP

310 PC Plus July 1996