Download physical symbol system - School of Computer Science

G52APT
AI Programming Techniques
Lecture 1: Introduction
Brian Logan
School of Computer Science
[email protected]
Outline of this lecture
• AI programming techniques
• Physical Symbol System Hypothesis
• AI programming as symbol manipulation
• AI programming languages
• aims of the module
• labs, coursework and assessment
What is Artificial Intelligence?
• “The study of how to make computers do things at which, at the
moment, people are better” — (Rich and Knight, 1991)
• “The branch of computer science that is concerned with the
automation of intelligent behaviour” — (Luger and Stubblefield,
1993)
• “The study of mental faculties through the use of computational
models” — (Charniak and McDermott, 1985)
• “The exciting new effort to make computers think … machines with
minds, in the full and literal sense” — (Haugeland, 1985)
What is Artificial Intelligence?
• many different definitions of AI
• AI as engineering: a set of techniques which allow computer programs
to do things that would require intelligence if done by a human
• AI as science
– “Weak AI”: whether it is possible for a machine to simulate
intelligence
– “Strong AI”: whether it is possible for a machine to actually be
intelligent
AI as engineering
• views AI as part of Computer Science
• set of techniques for solving problems for which no algorithmic
solution is (currently) known
• how such programs relate to human intelligence is not of interest
AI as science: Weak AI
• even if we build a system that behaves as though it is intelligent, it
wouldn’t necessarily be intelligent
• any realisation of intelligent behaviour by a machine is only a
simulation of intelligence
• c.f. Cognitive Science, which claims it is possible for a machine to
simulate human intelligence (including the kinds of errors, mistakes
etc. people make)
AI as science: Strong AI
• intelligence is essentially a kind of computation or information
processing
• any system which does the right kind of computation/information
processing necessarily is intelligent
• if it does the right kind of computation, it is possible for a machine to
actually be intelligent in more or less in the same way as a person
• may be many different ways of being intelligent
Physical Symbol Systems
• a physical symbol system consists of entities called symbols which are
physical patterns
• symbols can occur as components of expressions (symbol structures)
• an expression is composed of instances of symbols related in some
physical way (e.g., one symbol is next to another)
• the system also contains processes that operate on expressions to
produce other expressions
Physical Symbol Systems
• a physical symbol system is a machine that produces an evolving
collection of expressions
• such a machine exists in a world of objects
• an expression designates an object if, given the expression, the system
can either affect the object itself or behave in ways depending on the
object
• the system can interpret an expression if the expression designates a
process, and if, given the expression, the system can carry out the
process (e.g., addition)
Physical Symbol System Hypothesis
“A physical symbol system
has the necessary and
sufficient means for general intelligent action.”
– Newell & Simon (1976)
Physical Symbol System Hypothesis
• necessary: any system that exhibits general intelligence will prove on
analysis to be a physical symbol system
• sufficient: any physical symbol system of sufficient size can be
organised to exhibit general intelligence
• general intelligent action: the same scope of intelligence as we see in
human action
Physical Symbol System Hypothesis
• the PSSH can be seen as formalisation of ‘classical’ or ‘symbolic’ AI
– logic/theorem proving
– heuristic search
– planning, etc.
• cf numerical/statistical approaches to AI (connectionism, Bayesian)
AI programming
• symbolic AI programs can be hard to write in conventional
programming languages:
– languages such as FORTRAN, C, C++, Java etc don’t have a
‘symbol’ type (strings are not symbols)
– implicitly assume that the problem is reasonably well defined, e.g.,
to allow (static) types to be defined
– low-level – for example, programmer must allocate/deallocate
memory
AI programming languages
• AI languages were developed to support symbol manipulation
• also pioneered many features now taken for granted in ‘mainstream’
programming languages, for example:
– automated garbage collection
– virtual machines (cf JVM)
– windows, mice & bitmapped displays
– integrated development environments
• were all initially developed for AI programming languages
Lisp
• one of the first AI languages
• developed by McCarthy et al at Stanford (1959)
• many dialects (MACLISP, Lisp Machine LISP, Inter-LISP, Scheme,
etc)
• standardised as COMMON LISP in 1984 (ANSI standard in 1994)
• ‘functional’ language with very simple syntax (s-expressions)
• makes it easy to write programs which modify themselves or write
other programs
Lisp machines
• provide hardware support for
evaluation of Lisp programs
• entire system (including the
OS) written in Lisp and could
be modified by the user
• first single-user workstations,
with bitmapped graphics,
windowing systems, mice,
networking, laser printing etc
Pop-11
• developed by Popplestone & Burstall (1966) in Edinburgh (Pop-2) and
later ported to PDP-11 at Sussex (1976) (Pop-11)
• Pop-11 is incrementally compiled, and was one of the first languages to be
implemented using a virtual machine (PVM)
• similar expressive power to Lisp, but with an Algol-like syntax
• Pop-11 forms the basis of the Poplog programming environment which
allowed the development of programs in Pop-11, Lisp, Prolog and ML
• used extensively in the Alvey Programme (1983) – UK version of the
Japanese Fifth Generation Computer Project
Prolog
• developed from work on logical approaches to AI, e.g., PLANNER,
micro-PLANNER, CONNIVER etc, and NLP
• first implementation by Colmerauer & Roussel (1972)
• first practical implementation by Warren (1977)
• standardised in 1995 (ISO/IEC 13211-1)
• chosen as the language for the Japanese Fifth Generation Computer
Project (1982)
(in)Efficiency of AI programming languages
• often a perception that AI programming languages are inefficient, and
that programs written in an AI language are necessarily slow
• in reality, AI programming languages often compare favourably to
conventional programming languages, such as C, C++ and Java
• any small loss of performance resulting from using an AI language is
more than offset by the speed of development and the ease with which
complex algorithms can be coded
An example
relative performance of state-of-the-art ontology debugging systems:
• MUPSter and Pellet (written in Java)
• AOD (written in Pop-11)
'#!!"
'%!!!!"
*+,"
'!!!"
-./0123"
%!!"
$!!"
'#!!!!"
!"#$%&'$(&)*$
/24421"
&!!"
()**)+"
,-(.+)/"
012"
'$!!!!"
'!!!!!"
&!!!!"
%!!!!"
$!!!!"
#!!"
#!!!!"
!"
#)
!(
)!
!"
)!
!(
'!
!!
"
'!
!!
(#
)!
!"
#)
!!
()
!!
!"
)!
!!
('
!!
!!
"
'!
!(
#)
!"
)!
('
!!
"
#)
()
!"
'!
(#
)"
!(
'!
"
!"
'!"
#!"
$!" %!" &!" '!!" '#!" '$!" '%!" '&!" #!!"
!+,-.$/'.01+$2$3-)45.6%7.$)-8'$
Prolog example (route planning)
Prolog example (route planning)
route(X,Y,[drive(X,Y)]) :road(X,Y).
route(X,Y,[drive(X,Z)|R]) :road(X,Z),route(Z,Y,R).
road(arad,timisoara).
road(arad,sibiu).
road(arad,zerind).
road(zerind,oradea).
road(sibiu,fagaras).
road(sibiu,rimnicu_vilcea).
etc ...
Common features of AI languages
• interpreted or incrementally compiled (often with compilation as an
option)
• very high level – garbage collection, dynamically typed, ‘correct’
arithmetic etc.
• extensible – macros, meta-programming features, etc.
• high level of IDE support
AI program development
• AI languages are designed to support development of programs to
solve complex, poorly-understood problems
• typically no clear specification when programming begins
• problem becomes clearer through initial attempts to solve it
• focus on specific problem instances – ‘microworlds’
• this exploratory style of programming has some similarities with agile
software development methodologies, e.g., test driven development
Module aims
• to introduce basic AI programming techniques and explain how these
can be used to solve typical AI problems (e.g., G51IAI and G52PAS)
• programming techniques are introduced through an AI programming
language (Prolog)
• emphasis is on transferrable AI programming skills rather than
language specific details
• key AI problems are used to illustrate practical exercises, e.g., basic
search, planning, game playing, etc.
Prolog
• topics covered include:
– introduction to Prolog
– Horn clauses
– unification
– backtracking
– lists and other data structures
– AI programming patterns
AI programming
• how to use Prolog to implement
– search algorithms: e.g., depth-first search, best first, A*, iterative
deepening
– planning algorithms: e.g., regression planning, partial order
planning
Plan of the module
• lectures are on Wednesdays at 12:00 and Thursdays at 14:00 in C60
• labs are on Tuesdays 15:00–17:00 in B52
– labs start on the 14th of February
– there are no labs in the first two weeks of term
Assessment
• 75% exam (90 minutes)
• 25% AI programming coursework (in Prolog)
– coursework is due on Monday 26th of March (provisional)
Suggested reading
The recommended text books for the module are
• Bratko (2001), Prolog Programming for Artificial Intelligence, (3rd edition),
Pearson (or the 2nd edition, which covers all the material required for the
module)
• Sterling & Shapiro (1994), The Art of Prolog, (2nd Edition), MIT Press
Other useful sources include:
• Russell & Norvig (2008), Artificial Intelligence: A Modern Approach,
Prentice Hall (or the 1st or 2nd editions)
• Blackburn, Bros & Striegnitz (2006), Learn Prolog Now!, College
Publications (free online version at learnprolognow.org)
There will be suggested reading for each lecture from the Bratko book
Module web page
web page for the module is available at
http://www.cs.nott.ac.uk/~bsl/G52APT
• reading list
• suggested reading for each lecture
• lecture slides –WARNING: the slides are not ‘lecture notes’ and are
not a substitute for taking your own notes or reading the suggested
reading for the module
The next lecture
Prolog syntax
Suggested reading:
• for this lecture: Russell & Norvig (2008), chapter 1.
• for the next lecture: Bratko (2001) chapter 1.