Welcome to CSE473
Welcome to CSE473. Here are a few notes related to
the definition of AI and what we will be studying in the
course.
What is AI Anyway?
A lot of you are probably wondering what AI is, and what
we're going to be studying in this class, and maybe
what the relationship between the two is.
AI is a strange field because it's as much of an issue
to come up with a definition of the problems we try to
solve as it is to solve them. Either you tend to like
that or it drives you crazy.
One of the first "definitions" of the term came in the
1940s, from Alan Turing. His definition is totally
operational. To decide whether a computer program is
"artificially intelligent" you conduct a test in which
a human has two screens in front of him, one is connected
to a different human and the other to a computer program. He is given
some period of time (say several hours) to interact with
both entities, and there are no restrictions on the questions
he can ask. At the end of that time he has to decide which
one is human. If enough people guess wrong enough of the
time, then the program is "artificially intelligent."
That's actually a very compelling definition, because it
points out that a program doesn't have to think like a
human being in order to be intelligent: intelligence is
really decided by what a program (or other being) does
rather than by how it does it, or to put it another
way, IO behavior is everything.
There are two big problems with the Turing test though. The
first is this idea that you're communicating through a very
narrow communication channel, essentially using Unix talk
to communicate. Things that really seem to indicate intelligence---gestures,
facial expressions, tone of voice, even manual dexterity---are lost in
this definition.
More important, however, is that in a weird sense it's overly
narrow in that it equates ``intelligence'' with ``conversational
human-like behavior.'' Imagine a big automated factory, where all the
machines are servo-controlled. Further imagine that there is a
central computer, or more likely a big network of computers, that
completely controls the factory's operations. You give it production goals,
and the computer does the rest: it orders raw materials, schedules the machines,
routes the output, diagnoses and fixes problems with the assembly
line, even schedules and performs preventative maintenance on
the machines and even on itself. Is that computer intelligent?
Certainly not by Turing's definition, since it probably can't tell you
what it's doing, much less discuss poetry. But in a very interesting sense it is
intelligent with respect to its environment. It can't
discuss the weather with you, but it can be very "smart" when it comes
to running all aspects of its factory.
It's this "intelligent agent" concept of AI that is very
attractive to many people (including all of us at UW) at the moment.
There are several implications to taking this view. First of all
intelligence is still measured in terms of "IO behavior," but
IO behavior is not necessarily conversation. For
our agents, IO could be any one of a number of operations. Etzioni's
software agents, for example, communicate with the world using Unix
commands. One of my students is building an intelligent travel
agent that communicates with the human user using (restricted)
English language, but that communicates with the reservation database
over a TCP/IP channel. The automated factory manager has all sorts
of servo controls that constitute what it can do to the world and
all sorts of electronic or visual input from the factory that constitutes
its sensors.
The second and most important implication of this view of AI is that
intelligence should always be measured with respect to a particular
domain, or with respect to a particular set of problems to be solved.
This is a relief to us, since "general human intelligence" (i.e.
building Data the robot) is a long long way off, and it's nice that
we can build useful technology in the short term!
What is distinctive about solving problems from an AI perspective?
Put that way, AI seems pretty mundane: we build programs that solve
certain problems and that do "smart" things in various domains,
but that might be a good characterization of an operating system
or a thermostat too. Are the problems or techniques associated with
AI different from those in any other discipline of computer science?
In my opinion the answers to those two questions are no and
yes respectively. One weird thing about AI is that the
definition of an "AI problem" tends to change: once we solve a problem, in some
peoples' minds it's not AI any more. A great example is the first
FORTRAN compilers. Compiling a long program was definitely thought
to be kind of mysterious, and definitely required intelligence. But
not any more. Likewise chess: one of the first AI efforts was
to build a chess-playing program, and now they've succeeded in
building machines that play at the grandmaster level, but the curious
thing is that nobody (even people who agree with the "IO Behavior"
criterion for intelligence) think that these machines are intelligent!
That's because we all know and understand the algorithms they use,
and they're no longer mysterious. One danger that AI has to watch
out for is never getting credit for the cool things it does!
While an "AI problem" is pretty elusive, I think there are
techniques and methods that have been developed over the years
that are "distinctively AI," and that's what we will focus on
in the course. The first is symbolic programming, which is
just to say that we tend to look at data and data structures
as collections of symbols rather than as, say, matrices of
numbers. If you've forgotten your Lisp programming, symbols are
essentially equivalent to "enumerated types" in C++. We
just prefer to talk about the symbol GREEN somehow
referring to "the color green" even though we know it's implemented
as a bit in some bit vector. Likewise we love to manipulate
lists of symbols like (SALARY JOHN 5000) even though we know
it's just a pretty mundane data structure. Which is not to
downplay the importance of symbolic programming: for some problems
it's a very convenient programming abstraction, and one nice
thing about the class is you will get a good chance to add it
to your programming repertoire.
The other "distinctively AI" technique is something I'll call
"heuristic problem solving" for want of a better phrase. We have
long since realized that every problem we want to solve is NP-hard
or worse in the worst case, but it seems like in real life
the worst case rarely occurs. What's more, finding the absolute
optimal solution to a problem (say running errands) is often not
so important. So we would be happy with an algorithm
that does "pretty well" on most "common instances" of the
hard problem. The way we try to implement this idea is to try
to formalize our knowledge about a domain, often with rules like
"buy the ice cream after waiting in line at the post
office, especially on a hot day" and incorporating those heuristics
into the problem-solving algorithm. Another hot area of research
is in building programs that learn rules like that, thus making
themselves more effective problem solvers over time.
What are we going to study in this class?
The basic theme of the class is how to build simple agents,
and we will often talk about an agent in the Truckworld, which
is a fairly simple simulator that mimics a delivery truck.
The Truckworld is a pretty good domain because it's small enough
so you can understand it easily, yet it's complicated enough so
that virtually any AI problem will show up in the Truckworld
if you engineer the
world right. Also the simulator is written in Lisp, so it's
easy to integrate our problem-solving agents (which usually are
written in Lisp too) into their "environment."
You can look at the course syllabus (also on the web) for a more
specific idea of the topics. Mainly we're going to talk about
various ways to build problem-solving agents, but we'll also take
a brief spin through Language Understanding, just because it's
an interesting topic to study.
How is the course structured?
Pretty simple. The classes will be a mixture of lecture and
discussion, there will be five problem sets all of which will
probably involve programming, a midterm and a final. There
will be ample opportunity for extra credit if you find
you really like this stuff.
What are the prerequisites?
There are no strict prerequisites for the class. It
will help very much if you have had some experience programming
in LISP or a similar language, as all the of the programming assignments
will involve LISP programming. If you have no such experience, you
will have to do some catching up, especially at the beginning of the
course.
Why should you take this class?
Two reasons. First, as I said, you'll learn some interesting
new problem-solving techniques that could come in handy in
the years ahead. Second, it will be very unlike any of the
other CompSci classes in that there are no well-defined,
well-specified problems. Half the game (or half the battle)
is defining the problem; once that's done, finding good solutions
is relatively easy. Thinking about interesting problems
can be a lot of fun.
Why should I not take this class?
Two reasons. If you can't tolerate the Lisp programming
(either due to lack of experience or lack of desire),
you'll get swamped and/or angry. Second, some people really really hate
the idea that the problems aren't well defined. Those
people are well advised to stay clear of AI, since it will
be a hate/hate relationship from the very beginning.
Everybody else, I think, will be in for a fun time.
hanks@cs.washington.edu (Last Update: 01/04/98)