Introductionto agents

“ Introduction to Autonomous
Mobile Agents"
Juan Ramón Acosta
Network Computing Laboratory
Northeastern University

Introduction to Autonomous Mobile Agents 2
Outline
Introduction
1. Software Agents: Basics
2. Autonomous-Mobile Agents
3. Enabling Technologies
4. Application Engineering

Network Computing Lab
Head:
Dr. Dimiter R. Avresky
Members:
Natcho Natchev
Juan Ramón Acosta
Yavutz Varoglu
Marin Marinov
Steve Frechet
Luke Demoraski

Our Interests
 Optimization and Performance Analysis
 Fault-Tolerance
 Interconnection Networks
 Distributed Parallel Systems & Network
Computers
 Protocol Validation, Efficient and
Reliable Routing
 Agent Applications

Where to apply Agents
 Transparent Resource Allocation
 System Fault Tolerance
 System Performance Improvement
 Dynamic Network Reconfiguration

Network Computing
Discipline that studies homogenous and
heterogeneous Multi-computers and
clusters that are built using readily
available components and System Area
Networks (SANs)

 Reduce bandwidth usage
 Reduce total completion time
 Reduce latency
 Continue when disconnected
 Balance load
 Dynamically deploy components
Reasons for Using Agents

Dataset
Dataset
Dataset
Dynamically
selected
proxy site
Merged and
filtered data
stream
Reason 1:
Reduce Bandwidth Usage

Dataset
Dataset
DatasetFact
• Sending an agent avoids remote interaction.
Goal
• Avoiding remote interaction leads to faster
completion times.
Current Systems
• Do not meet the goal in all network environments
• Tradeoff: Local interaction vs. interpretive
overhead
Reason 2: Reduce Total Time

Reason 3: Reduce Latency
Sumatra chat server
[RASS97]
1. Observe
high average
latency to
clients
2. Move to
better location
2 to 4 times
smaller latency
in trial runs

Reason 4: Disconnected Operation
Dataset
Dataset
Dataset
Dynamically
selected
proxy site
X
Agent continues its task even
if the link to its home machine
goes down (temporarily).

Reason 5: Load Balancing
Machine A Machine B
Machine A Machine B
Agent moves to
balance load

Reason 6: Dynamic Deployment
Dataset
Dataset

Section 1
Software Agents:
Basics

Origins
 In 1970, Carl Hewitt proposed the “Actor Model”
 Actor, a computational Agent with an address and
behavior that communicates with other via
message-passing
 Based on Distributed Artificial Intelligence (DAI) and
Parallel Artificial Intelligence (PAI) theories and
formalisms
 Systems based on Actors became Multi-Agent
Systems (MAS)

Definition
Agent is a software/hardware component that
cooperate with other agents, interacts with its
environment, learns, is autonomous and has a
social contract with its user
Requirements:
 Cooperate with other Agents
 Learn (Interact with its Environment)
 Be Autonomous

Cooperate Learn
Autonomous
Smart
Agents
Collaborative
Agents
Interface
Agents
Collaborative
Learning
Agents
What is not an Agent
 Anything outside the
intersecting areas is not an
Agent
 Not Agents are: Expert
Systems, Knowledge Systems
and Distributed Processes
 Agents operate at knowledge
level not symbol level
 [Foner93] and Pattie Mae,
“Current commercially available
agents barely justify their name”
Figure 1. Agent Categories [Nwana95]

Collaborative Agents
Attributes:
Autonomous, Social Ability,
Responsiveness and Pro-
Activeness
Goals:
Create a system that
Interconnects other agents
to assemble a more complex
Function
Applications:
Distributed Sensor Networks,
Air Traffic Control and Enhance
Reliability
User 1 User 2 User 3
D-B1 D-B2 D-Bn
I-A1 I-A2 I-An
T-A1 T-A2 T-An
Proposed
SolutionTask
Layer 1
Layer 2
Infosphere
Figure 2. The Pleiades Architecture at
Carnegie Mellon University (CMU)

Interface Agents
Attributes:
Emphasis on autonomy and
Learning in order to perform
Tasks on behalf of the user
Goals:
Promote cooperation between
end users and software agents
Applications:
Assistants(Travelers,Schedulers)
Memory Aid, Filters, Match
Making, Buying or Selling on
behalf
Application
User A’s
Agent
User’s
Agent
User
Asking
User feedback
Programming by example
Figure 3. How Interface Agents Work
by Pattie Maes
Interacts
Interacts with
Communication
ObservesandImitates

Mobile Agents
Attributes:
Computational process capable
of roaming the network gathering
information on behalf of their
Owner to return later “home”
Goals:
Reduce communication costs,
Maximize local resources usage,
Create a flexible distributed
computing environment
Applications:
Personal intelligent
communicators, Emergency Alert
systems, Reconfigurable Mobile
Computing, Network Routing
A
A
Sensor
Sensor
A1
A1
Server
Email Notification
SMS Notification
Install Alarm
Figure 4. Whether Alarm System [Johansen99]

InformationInternet Agents
Attributes:
Manage or collate information from
Distributed sources and have
Knowledge where to look for and
find information
Goals:
Provide an expressive integrated
interface to the Internet
Applications:
Filtering Email, Meeting Schedulers,
System Maintenance, Newspapers
online.
User
Information
Agent Program
Lycos
Local cache
WebCrawler North Star Robot
Spider
Mite WAIS
URL Search
DBMS
World Wide
Web
Figure 5. WebBot running in Browser
[Nwana95]

Reactive Agents
Attributes:
Respond to stimulus generated
By the environment, manages
complex patterns that emerge
from this behavior
Goals:
Used to build systems with no
internal symbolic models and
Whose “smartness” derives from
interactions
Applications:
Physical Robots, Video games, Virtual
Worlds and Real-Time embedded
systems
Wonder
Avoid Obstacles
Explore
S
E
N
S
I
S
N
G
A
C
T
I
N
G
Figure 6. Brook’s Sumpton Architecture
[Nwana95]

Hybrid Agents
Attributes:
Agents constructed combining
one or more of the agent
types mentioned earlier.
Goals:
Maximize the strengths and
minimize deficiencies of some
techniques
Mental Model
World Model
Social Model
SG PS
SG PS
SG PS
Perception Communication Action
Agent KB Agent Central Unit
Cooperative Planing Layer (CPL)
Local Planing Layer (LPL)
Behavior Based Layer (BBL)
World Interface/Body
Figure 7. The InteRRaP Hybrid Architecture
[Nwana95]

Sociological View of Agents
 According to Leonard N. Foner, Agents must have a
“Social Contract”
 Contract must include:
 Discourse
 Risk and Trust
 Graceful Degradation
 Anthropomorphism
 Expectation
 Agents and their applications “need to be subject to
same behavioral analysis as human”
 An example: Julia TinyMUD developed at Carnegie
Mellon University can start polemical discussions

Section 2
Autonomous Mobile
Agents

Autonomous Mobile Agents
“ Components that operate without direct intervention of
humans, have control over its actions, internal state based
on knowledge and have the capacity to migrate from
machine to machine”
A
A
Sensor
Sensor
A1
A1
Server
Email Notification
SMS Notification
Install Alarm
Figure 8. Whether Alarm System [Johansen99]

Attributes
 Behavior can be predicted using beliefs,
desires and rationality
 Make choices based on what they know
about the world
 Roam the network using knowledge
 Create a flexible distributed environment

Agents as Intentional Systems
 Agent behavior can be predicted using beliefs,
desires and rationality
 Attitudes to represent an Agent
 Information.- Refers to the information de agent has
about the world it occupies, .e.g. Belief and Knowledge
 Pro-Attitudes.- Those that guide Agent Actions, e.g.
Desire, intention, obligation, commitment, etc.
 Agents make choices and form intentions on the
basis they have about the world, e.g. “stock order
matching rules”

Representation of Intentions
 Possible Worlds [Wooldrige94], semantic representation of
beliefs, knowledge. Goals are a set of states considered
possible
 Uses classical prepositional logic extended with two new
operators: = necessarily and = possibly
 Omniscience Problem, An Agent knows all proposition
tautologies then the agent knowledge is closed under
logical consequence
 Alternatives to this problem: Belief and Awareness, and
Deduction Model
 Meta-Languages [Wooldrige94], a syntactic representation
between a Meta-Term and Agent.

Mobile Agent Computing Model
Communication Infrastructure
(SCI, Myrinet, ServerNet, VIA, Ethernet, etc…)
Message-Passing
Subsystem
Agent Execution
Environment
Client Application
Environment
Message-Passing
Subsystem
Agent Execution
Environment
Client Application
Environment
RPC, JNI,MPI, PVM,CORBA
Tcl/tk, Java, C++
J.R.Acosta defines the three bottom layers as an Agent Service Broker

Agent Process Migration
 Strong Mobility
 Data, Code and
Control Block
 Weak Mobility
 Data and Code
Agent
Run
prc_cn
tl_blck
Ctrl
Blck
I
D
CtrlB
lck
Agent
Susp
I
D
CtrlB
lck
Ctrl
Blck
Agent
Run
Client Application Server Application
7. Resume
1. Migrate
2. Suspend
3.Generate
Bundle
4. Transmit
5. Receive
Bundle
6. Spawn
New
Process
6. Restore
State
8. Interact
Host A Host B
Agent
Susp
Code
Code
Figure 10. Process Migration

Advantages
 Access resources locally and eliminates
transfer of intermediate data, incrementing
efficiency
 Do not require permanent connections
 Load Balance
 Reduce Latency
 Portable and secure (Uses interpreted
languages)

Section 3
Enabling Technologies

Aglets
• Java
• Weak mobility
• Event-driven programming model
(dispatch, onDispatching, onArrival, …)
• Persistent store
• “Proxies” for location transparency
• Machine protection
http://www.trl.ibm.co.jp/aglets/IBM

Jumping Beans
Central
Domain
Server
Agency
“Mini-server”
Agency Agency
Jump
through
central
server
• Java
• Weak mobility
• Central server for tracking,
managing and authenticating
agents (but also failure point
and bottleneck)
http://www.JumpingBeans.com/
Ad Astra Engineering

Voyager
• Java
• Built on top of CORBA
• Weak mobility
• Federated directory service and group communication
(multicast)
ObjectSpace
http://www.objectspace.com/products/

Tacoma
• C, Tcl/Tk, Scheme, Python, Perl (public
release), several more internally
• Weak mobility
• Single, simple abstraction: meet
– Easy to add a new language
– Less opportunity for optimization
University of Tromsø / Cornell University
http://www.tacoma.cs.uit.no/

D’Agents (a.k.a Agent Tcl)
 Started by Robert
Gray in Spring, 1994
 Only system with
strong mobility
 Multiple Languages
 Tcl, Java and Schema
 Support Services
 Directory service
 Tracker
 Mobile Computing
 Performance
 Improving
 Communication and
Migrations are
Expensive
 Security
 Machine Protection
 Agent Protection in
Transit
 No Agent Protection
while on a Machine

D’Agents: Architecture
Figure 11. Agent Tcl Architecture [Gray97]
Transport (TCP/IP)
Server Engine
Java
VM
Scheme
Interp
Tcl
Interp
Agents
VM / Interpreter
Security
State
Capture
VM
Server
stubs

D’Agents: Example
Machine Z
Parent
Machine A
ChildChild
1. Submit
child
...
2. Jump
3. Send
results

D’Agents: Tcl Programming
proc child {machines} {
global agent
# migrate through machines
set results {}
foreach machine $machines {
# do task, update results
agent_jump $machine
}
# send back results and end
agent_send
$agent(root) 0 $results
agent_end
}
agent_begin
# submit child
set machines {A B …}
agent_submit
$agent(local-server)
-procs child
-vars machines
-script {child $machines}
# get results
agent_receive
code results -blocking
puts $results
agent_end
Child Agent Parent Agent

D’Agents: Java Programming
// Parent Agent
// register with the agent system
Agent a = new Agent();
AgentId id = a.begin (10); // timeout after 10 seconds
// submit the child agent
Vector machines = new Vector();
machines.addElement (new String (“A”));
machines.addElement (new String (”B"));
ChildAgent childAgent = new ChildAgent (machines);
AgentId childId = a.submit (“localhost”, childAgent, 10);
// wait for and display the result and then end
RecMessage result = a.receive (10);
System.out.println (result.getMessage());
a.end (10);

D’Agents: Java Programming
(Cont…)
class ChildAgent extends AgentEntryPoint {
private Vector m_machines; // machine list
public ChildAgent (Vector machines)
{ m_machines = machines; }
public void run (Agent a) {
String results = "";
// migrate through all the machines in the list
for (int i = 0; i < m_machines.size(); ++i) {
//do tasks, update results
String machine = (String) m_machines.elementAt (i);
a.jump (machine, 10);
}
// send back result and exit
Message message = new Message (0, results);
a.send (a.getRootId(), message, 10); a.end (10);
}
}

D’Agents: Performance
0
20
40
60
80
100
120
140
160
180
200
0 5000 10000 15000 20000 25000 30000
Payload or Message Size (bytes)
Time(milliseconds) D’Agents (Migration)
D’Agents (Messages)
TCP/IP connection
10 Mb/s
Network
Figure 12. Base Performance [Gray2000]

What Lowers Performance?
1. All messages through server (plus TCP/IP)
Server
Machine A Machine B
TCP/IP
connection Server
Machine A
Server
Tcl
Interp
TCP/IP
connection
jump
2. Interpreter initialization (plus TCP/IP)

D’Agents: Security
 Main concerns
 Protect the Machine from an Agent
 Protect Agents
 Protect Group of Machines
 Authentication
 RSA public-key cryptography to authenticate
agent’s owners
 Pretty Good Privacy (PGP) algorithm for digital
signatures and encryption for Agent migration and
communication

Filesystem
Manager
D’Agents: Protecting the Machine
Server
kernel
Security
Files
Tcl Agent
(digitally signed)
1. Authenticate
2. Accept or reject
3. Resume execution
4. open tutorial.ppt r
5. Access request (read)
and security vector
{owner, untrusted machines?}
6. Yes / no /
quantity
7. If yes,
open
Tcl
Interpeter

Going Forward
 Improve access restrictions and
resource scheduling for most
application environments
 Remote communication as fast as RPC
 Just-in-Time compilation with code
cashing

Section 4
Application Engineering

Application Engineering
 Agent Oriented Software Engineering
 Intelligent Software Engineering
 Agent Design Patterns

Agent Oriented Software
Engineering
 Specifies that a complex system can be
represented as a hierarchy
 Agents are:
 Problem solving entities in an environment
 Fulfill a specific role
 Control both their internal state and behavior
 Adopt goals and take initiative to satisfy their
design objectives

Agent Oriented Software
Cycle
Implementation:
Execute,
Compile
Verification:
Axiomatic
&
Semantic
Specification:
Beliefs, goals,
actions and
continuous interaction

Intelligent Software Engineering
[Deugo99]
 Concerned with the creation of principles to
describe intelligent software patterns
 Combine Patterns and Artificial Intelligence
Techniques
 Produce Complex and Intelligent Software
Products
 Agent Patters are Intelligent Software
Patterns

Design Patterns
 Created by Christopher Alexander. Applied to
Architecture
 Relation between a problem, its context and the
solution
 Format:
 Name .- Descriptive name for the pattern
 Problem.- Clear description of the problem to be solved
 Context.- Situation when the pattern might be applied
 Forces .- Items that restrict or influence when to apply
the pattern
 Solution.- Solution in the context that balances the forces

Agent Design Patterns
 Architectural Patterns, describe agent system
architecture
 Interaction Patterns, describe how agents
communicate with each other
 Agent Mobility Patterns, describe how agent
roam the network

Architectural Patterns
Name:
Layered Agent Pattern
Problem:
What software architecture best
supports the behavior of agents
Forces:
 Agent system spans several levels of
abstraction
 Software must include all aspects of
agency
 Be able to address simple and
sophisticated agent behavior
Solution:
Agents and the system needs are
discomposed into six layers
Mobility
Collaboration
Actions
Reasoning
Beliefs
Sensory
Figure 13. Layered Agent pattern,
[Kendall98]

Interaction Patterns
 Direct Coupling
 Point to point, Ack/Req, Agents do not move
 Proxy Agent
 Communication Session
 Badges
 Event Dispatcher

Proxy Agent Pattern [Deugo99]
Name:
Proxy Agent Pattern
Problem:
If the Agent sending a message does not
expect the receiving Agent to move or
Direct Coupling pattern is not applicable
for performance reasons, how do mobile
agent communicate with others ?
Forces:
 Mobile Agents change often position
 Communication peer-to-peer
 Required communication with static
Agents
Client Agent
Proxy Agent
Server Agent
Figure 14. Proxy Agent pattern
Solution: When Agent moves
away, agent creates proxy
Agent at its home location

Badges Pattern [Deugo99]
Name:
Badges Pattern
Problem:
How can an Agent find a suitable
communicating Agent without
specifying a concrete Agent?
Forces:
 Communicating Agents are not known
in advance and can change
 Design must be flexible and general
 After identifying communicating agents
communication should be direct
Solution:
Attach badges to agents. A place provides
a service to find a local agent
carrying certain badge.
Badge C
Badge B
Badge A
Look for Badge B
Figure 15. Badges Pattern
After finding an available
agent communication starts

Agent Mobility Patterns
 By Passer
 Commuter
 Interface
 Isolator
 Monitor
 Rover

By Passer Pattern [Hung2002]
Agents
 Used to avoid unreliable
links
 Works on behalf of the
client
 When finished it returns
to home
 If an Agent does not
return the pattern is
then called Commuter
Serve
r
AgentClient
Figure 16. By Passer Pattern

Interface Pattern [Hung2002]
Agents
 Act as intermediary
between a client and a
server
 Execute anywhere
 All communication
between client and
server goes through the
Agent
 If simple messaging
goes through the Agent
pattern is called Monitor
Server
AgentClient
Figure 17. Interface Pattern

Rover Pattern [Hung2002]
Agents
 Visits several sites
in sequence using
an itinerary
 Streamline recovery
model
 Helps to reduce
network congestion
Server
AgentClient
Server
Agent
Server
Agent
Agent
Figure 18. Rover Pattern

Performance of Agent
Patterns
Stock
Server
Roving
Agent
Roving
Agent
Roving
Agent
Static
Agent
Trader Host Roving Trader
Success Rate
95% Confidence
Interval
Host A 50.8% ±1.4%
Host B 100.0% ±0.0%
Host C 100.0% ±0.0%
Host A
Host B
Host C
Figure 19. Trading
System
[Hung2002]
Agents compete
to match the best
sale order of an
specific Stock
Symbol

Case Study
 Current Architecture
 Pattern Identification
 Agent Architecture
Self-Organized Multi-Modular Robotic
Control
Dr. José Negrete-Martínez
Facultad de Física e Inteligencia Artificial
Universidad Veracruzana, México
Figure 20. Modular Robot [Negrete 2002]

Case Study: Current Architecture
Motor(j)
B
DS Rotating(j)
m Payoff(j)
IRS AFD AD
n
Motor(j)
B
DS Probing(j)
Payoff(i)IRS AFD AD
SoftwareMechatronic
IRS .- Infrared Square Wave
DS .- Computer-servo’s interface
AFD.- Amplifier-Filter-Detector Circuit
AD.- Interface between AFD and
Computer
DS.- Computer-servo’s Interface
m,n .- Memory Register
Payoff(k).- function that calculates the sign of the difference
of light intensity before and after the module’s motor action
Decision(k).-function that adds a signed step to the present
position of the Motor(i). The Decision(i) function calls the
Payoff(i) function
Figure 21. Modular Architecture
[Negrete 2002]

Case Study: Pattern Identification
 Layered Agent Pattern, Use of Agent System that
supports mobility
 Monitor Pattern, Data Acquisition Agent in charge of
receiving Infra Red Signal and determining variation
on light intensity
 Commuter Pattern, Action Agents in charge of
executing the ‘Two Arm Bandit’ learning algorithm that
inputs the Payoff value and invoking and Orientation
Agent
 Event Dispatcher Pattern, Action Agent to report step
motor movement
 Interface Pattern, Motor Driver Agents that interfaces
with servo motor interface and a Action Agent

Desition
Agent
Case Study: Agent Architecture
Motor Driver
Agent
Action
Agent
SoftwareMechatronic
Orientation
Agent
DS
IRS AFD AD
Motor
moveMotorEvent
executeOtherAction
makeDesition
determineOrintation
haltActioEvent
newReading
stepMotor
Figure 10. Agent Architecture
Data
Aquisition
Agent

Case Study: Results
 Architecture is scalable and distributed
 Allows parallel continuous activity
 Remains Modular and better separation of
concerns
 Abstracts hardware Interfaces, more generic
 Enables System for Distributed Network or
Grid Computing

Conclusions
Agent technology promises big improvements
over traditional technologies and positions
itself as the future technology for complex software
systems.
However, as any other technology, it is only
good if it profs itself useful and people is willing
to spend time with it to solve problems
Otherwise it is a nice try

Introductionto agents

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Introductionto agents

Similaire à Introductionto agents (20)

Dernier

Dernier (20)

Introductionto agents

Notes de l'éditeur