What's the difference between an Expert System and an Intelligent Agent?
R. Sammut
an Expert System and an Intelligent Agent
thanks and a Happy new Year,
Mr. R. Sammut
[ comp.ai is moderated. To submit, just post and be patient, or if ]
[ that fails mail your article to <com...@moderators.isc.org>, and ]
[ ask your news administrator to fix the problems with your system. ]
howard chivers
news:aur4fg$6bf$1...@mulga.cs.mu.OZ.AU...
> Hi all, can someone explain what's the big difference between these two:
>
> an Expert System and an Intelligent Agent
>
> thanks and a Happy new Year,
> Mr. R. Sammut
I'm surprised this didn't start a debate, perhaps everyone's new year
resolutions are holding up?
try this for starters:
expert system tends to imply a particular kind of reasoning (IKBS etc)
intelligent agent could mean almost anything that reacts to its environment
Happy new year
Howard
---------------------------------------------------------------
Howard Chivers
how...@oddenhillfield.remove_this.demon.co.uk
(sorry about the continuing need for anti-spam,
please modify address before replying)
Hiram
like to "specialization". So, from an intelligent agent I'm expecting to
find an high capability to adapt the functioning to a wide range of
changeable in environment conditions. Instead, for an Expert System I will
find a very specialized system in some tasks.
Donald Fisk
>
> Hi all, can someone explain what's the big difference between these two:
>
> an Expert System and an Intelligent Agent
An expert system solves a problem which requires expert knowledge,
generally after a user inputs data.
The definition of intelligent agent is by no means as clear cut
as "expert system", but they're supposed to act autonomously on
behalf of a user, after acquiring data from their environment.
> thanks and a Happy new Year,
> Mr. R. Sammut
Le Hibou
--
Dalinian: Lisp. Java. Which one sounds sexier?
RevAaron: Definitely Lisp. Lisp conjures up images of hippy coders,
drugs, sex, and rock & roll. Late nights at Berkeley, coding in
Lisp fueled by LSD. Java evokes a vision of a stereotypical nerd,
with no life or social skills.
john bailo
they are both different implementations of the same idea...
an expert system embodies knowledge (content) using 1st order logic (
if then rules ) which are evualed using an 'inference engine' -- the
meat or core of the programming.
an intelligent agent, is an expert system on wheels -- that is, its
kind of like 'clippy' the little ms animated guy -- instead of
carrying his bag of content/knowledge with him, he can go out and find
things within a knowledge rich environment -- but, undoubtably, at his
core is some type of 'expert system inference engine' to make
decisions as to which answer is the most appropriate for the issue.
Juliana L Holm
> The definition of intelligent agent is by no means as clear cut
> as "expert system", but they're supposed to act autonomously on
> behalf of a user, after acquiring data from their environment.
An intelligent agent may be an expert "system" or rather an intelligent
autonomous agent; they can coexist, but they can also be separate.
Julie
R. Sammut
which is the best programming language to built an intelligent agent?
RS
Randolph M. Jones
> Hi all, can someone explain what's the big difference between these two:
>
> an Expert System and an Intelligent Agent
>
Here's my take, but rest assured this is by no means an "official
position". Expert system implies a significant amount of knowledge
engineered into the program. Agent implies a piece of software that
(relatively) autonomously interacts with some (fairly complex)
environment. I have my own qualms about whether a lot of agents should
be called "intelligent" or not, but as someone else pointed out you can
view these two things as orthogonal. You can have knowledge-rich
systems that are not highly autonomous or interactive ("traditional"
expert systems). Or you can have autonomous, interactive software that
doesn't have a lot of knowledge (sometimes called "light agents"). Or
you can have both (which I have recently become fond of calling "heavy
agents").
Randolph M. Jones
> thanks for your replies. Now i'd like to hear some suggestions on
> which is the best programming language to built an intelligent agent?
How intelligent do you want it to be?
What kind of environment is it going to interact with?
Does it need to learn? What kind of learning?
Hiram
| which is the best programming language to built an intelligent agent?
For my dynamic (or recurrent) artificial neural network (ANN), I've used
ANSI C and C++ but now, due to its portability onto different OS kernels
(linux, unix, win) I'm fascinating of Java (java.sun.com) and as development
environment eclipse (eclipse.org).
A low level language has low distance form machine kernel and CPU but have
high distance from an user frendly environment.
So, if you are developing a very complex system with calculations problems
and with speed problems for algorithm convergence I suggest low level
language.
If your desire is to develop a new algorithm or the study of an existent one
a choice to focus your attention on the algorithm could be the use of
Matlab.
john bailo
> thanks for your replies. Now i'd like to hear some suggestions on
> which is the best programming language to built an intelligent agent?
>
Without being too much of a 'tool', I would vote for using c# from
Microsoft's dotnet.
Why? Because the dotnet architecture is highly tied to the operating
system and network giving an intelligent agent lots of 'space' to play
in (i.e., can use RMI or Web Services to pull information from other
computers, can discover low level information using OS assemblies.
In addition, the dotnet architecture gives us the ablility to do data
'encapsulation' using meta data in assemblies -- if you follow my
reasoning and read up on assemblies, meta data and reflection --
you'll see where i'm driving as far as its applicability to build
intelligent agents.
I am working on a paper right now showing how ideally a kind of 'data
agent' can be built which challenges the idea of a centralized dbms --
here i propose that such a 'data agent' under control of a person who
would be a 'record in a dbms' can act as a response agent for
questions asked of a traditional database.
So we replace the row ( name/age ) with an agent who, when queried
with an age method -- can respond appropriately....and so on...
paulsnx2
> rs...@postmark.net (R. Sammut) wrote in message news:<aviemo$3bp$1...@mulga.cs.mu.OZ.AU>...
> > thanks for your replies. Now i'd like to hear some suggestions on
> > which is the best programming language to built an intelligent agent?
> >
>
> Without being too much of a 'tool', I would vote for using c# from
> Microsoft's dotnet.
>
> Why? Because the dotnet architecture is highly tied to the operating
> system and network giving an intelligent agent lots of 'space' to play
> in (i.e., can use RMI or Web Services to pull information from other
> computers, can discover low level information using OS assemblies.
>
> In addition, the dotnet architecture gives us the ablility to do data
> 'encapsulation' using meta data in assemblies -- if you follow my
> reasoning and read up on assemblies, meta data and reflection --
> you'll see where i'm driving as far as its applicability to build
> intelligent agents.
>
> I am working on a paper right now showing how ideally a kind of 'data
> agent' can be built which challenges the idea of a centralized dbms --
> here i propose that such a 'data agent' under control of a person who
> would be a 'record in a dbms' can act as a response agent for
> questions asked of a traditional database.
>
> So we replace the row ( name/age ) with an agent who, when queried
> with an age method -- can respond appropriately....and so on...
>
I am not sure I would agree with the idea that DotNet is in any way
ideal for such a system. After all, this will tie such a system to
DotNet and Windows, and limit the use of the resulting agent on other
platforms. Furthermore, it may result in an increase in maintanence
as one either attempts to keep up with changes in Microsoft's platforms.
In return for all of that, the only thing gained is integration with
the OS. BTW, such integration amounts to using function sets provided
by the OS, function sets that can be acquired in other ways (like a
minimal C# program).
C++ has been used to implement systems (like CLIPS, modeled after
ART). Java has also been used (JESS, modeled in turn after CLIPS).
Now the question becomes, are you building a Rules Based Expert System,
where people are responsible for providing some fixed set of rules?
Or do you want to build a system that "discovers" the rules it will
use for itself?
Either way, Java, XML, a good application server, and a good database
may be a rather reasonable way to go for a large set of applications.
Here is a bit I wrote about my experience on a ongoing system that
used a Decsion Table based Rules approach. (The approach avoids
an infrence engine, but qualifies as an Expert System, none the less):
I have worked with C++, as I used CLIPS (modeled after ART) on a
project in graduate school. However, on a recent project, I
build a Rules Engine in Java that has proved to be far easier to
verify and maintain, than CLIPS or ART rules. It uses Decision
Tables, and a more natural, extendable syntax for the conditions
and actions. These Decision Tables are in the form:
1 2 3 4
+--------------+---+---+---+---+
| Condition 1 | Y | N | N | N | The conditions are evaluated.
| Condition 2 | - | Y | N | N | This selects a column
| Condition 3 | - | - | Y | N |
+--------------+---+---+---+---+
| Action 1 | X | | | | The actions to be executed, in
| Action 2 | | X | | | the order specified in the table,
| Action 3 | X | | X | | are indicated by an X in the
| Action 4 | | | | X | selected column.
+--------------+---+---+---+---+
This was the format used by the Texas Department of Human Services
to document their policies for eligibility for the assistance programs
they provide. I immediately observed that were we (the vender) to use
this format directly, most of the maintenance issues of typical rules
systems could be avoided.
Two systems have been developed using my implementation of a Rules
Engine in Java.
The first system was a prototype for the full eligibility system called
STARS. STARS is an Internet application, getting 500,000 hits
per year. STARS has 80 decision tables that screen a household against
50 or so assistance programs. You can see this application if you go
to:
TIERS is the full eligibility system, and it started from the same
code base as STARS with only a few improvements. Actually, the deployed
system for TIERS is smaller than for STARS. This was the result of
moving the parser for the condition and action syntax out of the
deployed application. TIERS uses 3000 decision tables defining the
eligibility policy for all programs managed by the Texas DHS. TIERS
is currently in pilot, and will go into full production in 2003.
One might ask if OO might have been better. It isn't. In fact, there
was a vender change between STARS and TIERS. The new vender
was a few months into an OO solution, was already behind, and
scheduled to become the largest team on the project (there are six teams).
I came on, spent a month discussing the approach (and tuning the
STARS rules engine for the bigger TIERS project.) In the first month,
the business logic team divided in half and worked on both the
Decision Table approach and the OO solution. At the end of that
month, the OO team was still behind, while the Rules Approach had
caught up with the development schedule. They dropped OO, and
in the last year they have remained up to schedule and often ahead
of schedule. Oh, and they are the *smallest* of the six teams.
You can learn more about TIERS at
http://www.dhs.state.tx.us/programs/TIERS/
Now, I know this sounds a bit "self-promoting". None the less, the
approach was very powerful and flexible.
The STARS system was a Windows based system, and there was
no porting required to run the code on a Solaris box.
C# would not have been so easy to move over these
types of platforms.
Also, for this application (STARS is an Internet Self Screening
Application, for those of you who skipped to the end of this post),
close integration with the OS would have provided no advantages at
all. I suspect this to be true for most AI applications, possibly
excepting AI applications for maintaining or healing computer systems.
Even this I doubt, but that can remain the subject of another post.
All that said, Java is a poor language to use to write an interpreter.
The same rules engine written in C++ would be far faster, maybe
as much as 100x. However, the Rules Engine's ability to process
the equivlant of 3000 to 5000 forward chaining rules per second
was fast enough for both STARS and TIERS. (TIERS is likely to be
more like 5000 to 10000 forward chaining rules per second, a
result of more performance work and the use of a faster platform.)
Because federal dollars were used in the development of STARS
and TIERS, the Rules Engine and its source code are available
for any U.S. government project.
If anyone has any questions about the Rules Engine itself, (outside
the context of this thread) please feel free to contact me.
--Paul
pau...@urx.com
Eray Ozkural exa
>
> I am not sure I would agree with the idea that DotNet is in any way
> ideal for such a system. After all, this will tie such a system to
> DotNet and Windows, and limit the use of the resulting agent on other
> platforms. Furthermore, it may result in an increase in maintanence
> as one either attempts to keep up with changes in Microsoft's platforms.
>
It should be noted that research code should be platform independent
if possible. No fortune teller can know that a particular system will
be the (single) future.
(snip)
> C++ has been used to implement systems (like CLIPS, modeled after
> ART). Java has also been used (JESS, modeled in turn after CLIPS).
>
A more realistic answer is people have used all sorts of programming
languages to implement a host of AI systems.
Please read the related thread on using Haskell for AI programming.
My advice to anybody is to learn as many programming systems as they
can because no tool is sufficient for everything. Blind allegiance to
one language or platform doesn't solve your problems.
C and descendants are fairly low level languages. The assembly of
today is C++ and if you are doing really low level programming in
which you want to have precise control of operation like algorithms
research, such a language might be feasible. Otherwise the way to go
is high level languages with functions as first class values and
interpreters.
As a side note, if you are writing a sufficiently complex system you
will find yourself implementing several domain specific languages and
programming environments -- please don't think that XML will be the
storage representation and C++ will be the processing language. Thus,
it will be profitable to learn symbolic programming languages with
greater opportunities for realizing language processors, logical
systems, etc.
I am currently planning to use the ocaml language for my future AI
projects because its design has achieved a great combination of
orthogonality, abstraction and efficiency.
Thanks,
__
Eray Ozkural
paulsnx2
> pau...@urx.com (paulsnx2) wrote in message news:<b2kjgl$lhl$1...@mulga.cs.mu.OZ.AU>...
> >
> > I am not sure I would agree with the idea that DotNet is in any way
> > ideal for such a system. After all, this will tie such a system to
> > DotNet and Windows, and limit the use of the resulting agent on other
> > platforms. Furthermore, it may result in an increase in maintanence
> > as one either attempts to keep up with changes in Microsoft's platforms.
> >
>
> It should be noted that research code should be platform independent
> if possible. No fortune teller can know that a particular system will
> be the (single) future.
A reasonable observation! Of course, if
the problem you are trying to solve is related to that limited set
of platforms (i.e. there is something unique about .Net that you
are seeking to leverage or study), then go for it. If not, then
avoid it!
> (snip)
>
> > C++ has been used to implement systems (like CLIPS, modeled after
> > ART). Java has also been used (JESS, modeled in turn after CLIPS).
> >
>
> A more realistic answer is people have used all sorts of programming
> languages to implement a host of AI systems.
>
> Please read the related thread on using Haskell for AI programming.
The intended observation is that CLIPS and JESS allow some ability
to integrate C, C++, or Java code with the expert systems. (I was
not very clear on this.) I did some reading on Haskell, and the
same can be said for it.
The Rules Engine I wrote also allows easy integration with Java. This
is a rather important feature for web based applications where the
platform is much more likely to change over time, and Java, JSP, and
XML are playing larger roles in defining aspects of web based applications.
> My advice to anybody is to learn as many programming systems as they
> can because no tool is sufficient for everything. Blind allegiance to
> one language or platform doesn't solve your problems.
I could not agree more. I have programmed in dozens of Assembly
languages, written code on all types of platforms, from mainframes
to Unix boxes, embedded systems (like printers and radar system), and
Windows boxes. That range of experience helps to evaluate and
implement all sorts of systems using the best tools for the job.
> C and descendants are fairly low level languages. The assembly of
> today is C++ and if you are doing really low level programming in
> which you want to have precise control of operation like algorithms
> research, such a language might be feasible. Otherwise the way to go
> is high level languages with functions as first class values and
> interpreters.
Here I will protest a little. C++ does provide plenty of rope to hang
yourself with. If you are not careful, you will find yourself constantly
fixing low level issues like memory leaks and the like. However,
C++ also provides the opportunity code a wider range of solutions
to a particular problem by virtue of your control of the code. In the
Rules Engine approach I discussed earlier in the thread, I feel I lucked
out getting the performance I needed using Java. A C++ solution would
have been perhaps 100 times faster.
> As a side note, if you are writing a sufficiently complex system you
> will find yourself implementing several domain specific languages and
> programming environments -- please don't think that XML will be the
> storage representation and C++ will be the processing language. Thus,
> it will be profitable to learn symbolic programming languages with
> greater opportunities for realizing language processors, logical
> systems, etc.
Here I will defend XML a bit:
I am a big fan of XML for storage for data that is relatively static.
If you expect lots of CRUD (create, read, update, delete) operations
against your storage representation, then use a database. If you are
just going to do one pass over the entire data, use XML.
Simplicity is the significant advantage of XML over a database like
Oracle or DB2. No drivers, no expensive database to install, etc.
XML can be checked in and out of your Software Control and
Management system.
Distribution of your system (that interest expressed above) is much
easier via XML over the use of a particular database or database API.
For databases with light CRUD requirements, I'd rather see some
code implementing an object database over XML that a solution that
uses an expensive database. I have not, however, done this yet as
in the business world, management and clients love those expensive
databases.
Do not overlook LEX and YACC (or the java versions of the same,
JFlex and CUP) for the implementation of languages and interpreters.
In fact, I prefer using JFlex for parsing XML because it is 1) Faster,
2) Easier to write, 3) Easier to maintain, 4) avoids needless memory
allocations done by SAX or DOM, and 5) avoids a dependency on
huge libraries like SAX or DOM.
> I am currently planning to use the ocaml language for my future AI
> projects because its design has achieved a great combination of
> orthogonality, abstraction and efficiency.
>
> Thanks,
>
> __
> Eray Ozkural
None of this post should be taken as an argument against languages like
ocaml or Haskell. The goal should always be to pick the language
and the platform that will reduce the semantic gap between your
problem and your code. However, one cannot avoid the pragmatic
problems of selling your choice of tools to your management or
clients. So if you are forced to use C++ or Java, there remains tools
to build what you need to first reduce the semantic gap before
addressing the core operational code of your project.
--Paul
john bailo
> agent' can be built which challenges the idea of a centralized dbms --
> here i propose that such a 'data agent' under control of a person who
> would be a 'record in a dbms' can act as a response agent for
> questions asked of a traditional database.
Then you might want to try a web service. That automatically gives
platform indepenence to the client, while allowing the developer to
exploit the chosen platform to its extents.