12.1 What are Agents?

12.1 What are Agents ?

There was a lot of controversy over what constituted an object when object programming was initially introduced. There is a similar controversy over exactly what constitutes an agent. Many proponents define agents as autonomous, continuously executing programs that act on behalf of a user. However, this definition can be applied to some UNIX daemons, or even some device drivers. Others add the requirements that the agent must have special knowledge of the user , must execute in an environment inhabited by other agents, and must function only within the specified environment. These requirements would exclude other programs considered to be agents by some. For instance, many e-mail agents act alone and may function in multiple environments. In addition to agent requirements, various groups in the agent community have introduced terms like softbot, knowbot, software broker, and smart object to describe agents. We define the term agent iteratively in this chapter. We start with some simple, agreed-upon partial definitions and construct a definition that is practical for C++ programmers.

One commonly found definition defines an agent as an entity that functions continuously and autonomously in an environment in which other processes take place and other agents exist. Although it is tempting to accept this definition and move on, we cannot because it too easily describes other kinds of software constructions. Many object-oriented components function continuously and autonomously in an environment in which other processes take place and other objects exist. In fact, many CORBA-based client-server systems fit this description! So if we exchange the word object for agent in this definition it accurately describes many object-oriented systems. A look at a more formal source, the Foundation for Intelligent Physical Agents (FIPA) specification defines the term agent accordingly :

An Agent is the fundamental actor in a domain. It combines one or more service capabilities into a unified and integrated execution model which can include access to external software, human users and communication facilities.

While this definition has a more structured feel, it also needs further clarification because many servers (some object-oriented and some not) fit this definition. This definition as is would include too many types of programs and software constructs to be useful. Although we rely on the FIPA specification where we discuss agents, this basic definition requires further work.

12.1.1 Agents: A First-Cut Definition

One of the reasons that the word object can in so many instances replace the word agent in so many definitions and descriptions of agent is because agents are inherently based on objects. In fact, our initial requirement on the definition for an agent is that it first fit the definition of an object, [1] that is, we designate an agent as a certain kind of object. This chapter is largely about what makes an agent different from other classes of objects. In the same sense that C++ has support for interface classes, container classes, and framework classes, we can also designate agent classes. This brings us to our second requirement on the definition of agents within a C++ environment. In C++ an agent is implemented using the notion of a class. The different types of classes are distinguished by how they function or how they are structured. For instance, a container class describes an object used to hold or contain other objects. An interface class is used to describe an object that transforms or adapts the interface of another object. A framework class describes an object that contains a pattern of work that is common to a family of other objects. An agent class will be used to define objects that have what Yohav Shoham (1997) describes as a mental state: "The mental state will contain such components as beliefs, capabilities, choices, and commitments." This mental state is often partially summarized by the Belief Desires and Intentions (BDI) model. We extend the BDI model to include actions. So in our first-cut definition of agents, we define an agent as a piece of software meeting the following three requirements:

[1] When we use the term object in the definition of agent we include its AI cousins: actor and frame.

  1. A certain type of object (not all objects are agents)

  2. Implemented using the notion of a class (encapsulation, inheritance, and polymorphism are important for agents!)

  3. Contains a set of behaviors and attributes that must include beliefs, desires, intentions, and actions

For our purposes, agents are by definition rational software components. Before we define agents further, lets look at the types of agents that are commonly implemented.

12.1.2 Types of Agents

Several categories of agents have emerged. Although not every agent fits into one of these categories, the categories are generally descriptive of the majority of agents in practical use. Table 12-1 contains five major categories of agents. Obviously there are hybrid agents that fit into more than one category at the same time. There are no hard and fast rules that determine which agents fit into any particular category. These categories are presented for convenience and as a starting point when trying to classify agents that you may have to develop or work with.

Table 12-1. Five Major Categories of Agents

Agent Categories

Description

Interface agents

Represent the next generation of human “computer interaction. These agents provide new user interfaces to the computer.

Search agents

Perform various types of information retrieval.

Monitor/control agents

Patrol, observe, audit, manage, and monitor devices and conditions, data, and processes.

Acquisition agents

Authorized to acquire some good or service on behalf of the user.

Decision support agents

Provide analysis, information synthesis, condition and data interpretation, planning, and evaluation.

Table 12-1 represents a functional breakdown of the agent categories. It does not specify any particular components that the agents must have. It only specifies the types of activities that the agents engage in. In fact, these categories are not the exclusive domain of agents. Other classes of software such as expert systems and object-oriented systems have categorizations very similar to these. In some cases, the only difference is that we are talking about agents as opposed to objects or expert systems.

12.1.3 What is the Difference between Objects and Agents?

One of the fundamental requirements for an agent is that it first meets the conditions of object orientation. So agents and objects have more things in common than many of the agent proponents would like to admit. It is the function and construction of the object that places it into the agent column. Objects are by definition self-contained and exhibit a certain amount of autonomy. Once the degree of autonomy crosses a certain threshold and the object is given cognitive data structures such as those found in the BDI model, then the object is an agent. An autonomous rational object is an agent. [2] An object is considered rational when it has:

[2] We intentionally avoid the term intelligent. It is not currently known whether we will ever produce intelligent software. However, we can undoubtedly produce rational software based on well understood , logical formalisms.

  • Methods that implement some form of deduction , induction, or abduction

  • Data members that are implementations of cognitive data structures

Keep in mind that in object-oriented programming, the routines defined for a class are called methods and in C++ they are called member functions. The variables or data components defined for a class are called attributes and in C++ they are called data members. If some of the member functions are used to perform deduction, induction, or abduction on the data members that are implementations of cognitive data structures, then the object is rational. If the rational object also crosses a certain threshold of autonomy, then it is an agent.

Cognitive data structures are structures used to represent mental constructs like beliefs, intentions, commitments, decisions, moods , and knowledge. For instance, we could designate a believe structure using a C++ set:

 set<statements> Beliefs; struct   statement { //...    float ArrivalTime;    float DepartureTime;    string Destination;    //... }; 

where the statements are about schedule some form of public transportation. A collection of these statements is stored within set<statements> and represents the agent's beliefs. This is what we mean by data members that are implementations of cognitive data structures. The agent would declare the data member accordingly:

S 12.1. Deduction, Induction, and Abduction

Deduction, induction, and abduction are processes used to draw conclusions from a set of statements or a collection of data. The process of deduction allows the reasoner to deduce a conclusion from a set of statements. If the statements are true and the reasoner follows the proper rules of inference, then the conclusion is said to be necessarily true or that it follows by necessity. For instance:

All three-sided figures are triangles .

This is a three-sided figure.

This is a triangle. Conclusion arrived at by deduction

The rules of inference are guidelines and restrictions that determine how the reasoner may move from one statement to another. The rules of inference determine when statements are logically equivalent and the conditions under which one statement may be transformed into another. Sidebar Figure 12-1 contains the eight most basic rules of inference.

. Sidebar Figure 12-1 Rules of inference taken from the back inside cover of COPI symbolic reasoning.

graphics/12sbfig01.gif

The process of induction allows the reasoner to induce the conclusion from a set of statements taken to be facts. For instance:

It rained yesterday .

It rained the day before.

It rained all last week.

It will rain tomorrow. Conclusion arrived at by induction

Whereas the conclusions in the deductive process are said to be necessarily true (if the rules of inference were applied correctly), the conclusions in an inductive process have only a probability of being true. How close that probability is to 100% will depend on the nature and context of the statements and data they are drawn from. The process of abduction allows the reasoner to draw the most plausible conclusion based on a set of statements or data. For instance:

Articles of the defendant's clothing were found at the scene of the crime.

The defendant and the deceased recently had a violent argument.

The defendant's DNA was found at the scene of the crime.

The defendant is the perpetrator of the crime Conclusion arrived at by abduction

Deduction, induction, and abduction are the three fundamental processes found in logic. They provide for logic what calculation and arithmetic provide for mathematics. The ability to correctly move from premises (statements, data, and facts) to conclusions is the process that we call reasoning.


 class agent {    //...    set<statements> Beliefs;    //... }; 

The agent class uses deduction, induction, or abduction to process its Beliefs in order to form intentions, commitments, or plans. A closer look at our definition of agents states that if it is a rational autonomous object, it is an agent. If it is not rational, then its not an agent, it's just an object. The degree of autonomy is another area of debate and we will examine it closely later in this chapter.



Parallel and Distributed Programming Using C++
Parallel and Distributed Programming Using C++
ISBN: 0131013769
EAN: 2147483647
Year: 2002
Pages: 133

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net