An Intelligent Interface-Agent Framework for Supervisory ...
Developing a Distributed Dynamic Intelligent Agent Framework Based on the Jini Architecture
description
Transcript of Developing a Distributed Dynamic Intelligent Agent Framework Based on the Jini Architecture
Developing a Distributed Dynamic Intelligent Agent Framework
Based on the Jini ArchitectureHarry Chen
Department of CSEE
U. Of Maryland Baltimore County
Introduction
Developing a framework for dynamic distributed systems..
Ronin Agent Framework – Introduces a hybrid approach based on the agent-
oriented and service-oriented programming designs– deploys a dynamic distributed system with
“intelligence”. Ronin provides solutions for the problems
raised by the existing agent frameworks.
Overview
Observations– The future computing trends.
Motivations for developing Ronin– The Jini architecture– Agent technology
The Ronin Agent Framework Agents2Go & Ronin
Computers & devices are connected in networks.– Wireless connection is gaining its popularity.
Distributed computing is the trend of the future. – PDAs and cellular phones are now capable of doing
computation. People are spending more time with
computers.– Shopping, work, entertainment etc.
The Future Trends
Observations
Networks are by nature dynamic.– “Things” come and go.– “Things” need to find each other.
“Things” are not homogeneous.– A laptop computer wants to talk to a web server as
well as a cellular phone. “Things” need to be smart!
- People can’t spend all of their learning and telling these “things” what to do everyday!!
Observations
We need tools to develop flexible and robust distributed system with “intelligence”.
The Jini architecture seems to be a good framework for developing dynamic distributed systems. – Why is Jini good?– Is Jini the answer?
The Jini Architecture
A simple Java-based infrastructure for providing services in a network.
Each Jini system is built around Lookup Services (LS). – Service client finds services through the LS.
Each service implements a set of well-known service interfaces.– Service client knows how use a service because of
the client knows how to use the interface!
A Typical Jini Service
The Printing Service– Bob needs to print 1000 copies of color brochures
from his laptop.– Bob connects his computer to the network, specifies
a set of lookup attributes for finding a printer.– The LS returns a matched print service.– The client application invokes one of the print
service method, and the job is done!
A Closer Look at the Jini Architecture
There is a catch with the Printing Service scenario.
Finding a good service match Bob has to know about all of the lookup attributes. – A service might have hundreds of attributes. Bob
might not understand all of the attributes.– Bob might not know his file must be printed on a
PostScript printer.
A Closer Look at the Jini Architecture
How can we help Bob?– Give Bob a “smart” agent that can help Bob to make
decision.– The agent finds an appropriate printer for Bob
based on the properties of the print file and the user profile of the Bob.
No need for Bob to learn about the service detail
Reduce the chance of making human errors.
What Can We Say About Jini
Jini is good.– Jini provides flexible and robust infrastructure for
deploying and finding services. – The service-oriented design provides an uniformed
infrastructure for distributed entities to interact. – Developing a Jini service is easy.
What Else Can We Say About Jini
Jini alone is not the answer for everything. Developing a “smart” Jini service is hard.
– Why is it hard? To be adaptive, it needs to learn from the environment and
the past; it needs to cooperate with other services. To be autonomous, it needs to know how to make plans
and schedules; possibly it needs to know how to represent knowledge and reason.
And more …
Searching for Answers
Software agent model contains the properties that we are looking for:– Agents are autonomous.– Agents can learn from the past.– Agents can cooperate with other agents.– Agents can adapt and react to their environment.
If we can model a Jini service to have the same properties as a software agent, then we are done!
Software Agents
The key idea is that agents can act exactingly in order to accomplish tasks on the behalf of their users.
Software agents offer a new paradigm for very large scale distributed heterogeneous applications.
The paradigm focuses on the interactions of autonomous, cooperating processes which can adapt to humans and other agents.
Software Agents DO Communicate
Software agents communicate with each other using Agent Communication Language, ACL.
ACL is important for agent paradigm, just as the development of human language was the key to the development of human intelligence and societies.
Agent Communication Languages
Knowledge sharing approach– KQML, KIF, Ontologies
FIPA
Shared objects, procedure callsand data structures
Shared facts, rules, constraints, procedures and knowledge
Shared beliefs, plans, goals,and intentions
e.g., CORBA, RPC, RMI
e.g., KQML, FIPA, KIF, Aglets
e.g., ?
KnowledgeSharing
IntentionalSharing
?
ObjectSharing
Building Software Agents
Building smart agents we need sophisticated tools, for example.– Agent Communication Languages (ACL).– Rule-based programming.– Domain knowledge representation and reasoning.– Constraint problem solving.– Planners.– And more depends on the domain problem.
Problems Raised by the Existing Agent Frameworks
Lacking of sophisticated tools in Java. Restricted ACL for agent communications. Restricted network protocol. Difficult to integrate heterogeneous agents
systems.– Message representation are different.– Communication scheme are different.
Task 1: Making sophisticated tools to be available for developing agents.
Task 2: Merge the agent architecture with the Jini architecture, taking advantage of the best parts of each.
Our Tasks
Task 1: Making Tools Available
We can implement all of these sophisticated tools in Java. – Takes long time and it is not so trivial.
We can reuse the existing tools and create Java interface for agents to use. – Easy! Create Jini services for these sophisticated
tools.
Making Prolog Available
Prolog engine is an excellent tool for building inference engine and knowledge base.
We have created a Jini service called Distributed Prolog KB (DPKB), to provide simple knowledge base operations for Jini enabled agents.
Prolog Engine
SICStus Prolog– Jasper Java package
PrologEngine– Wrapper class for
SICStus prolog engine
SimplePrologKB– KB operations to
PrologEngine
Jini Prolog KB Service - DPKB
Features.– Heavy-weighted Prolog Engine runs on the server
side. Clients do not have to install native Prolog code.
– Clients can have multiple KB through 1 DPKB service.
Each KB is identified by KB ID and KB password.
Client only sees this
Runs on the server
The Ronin Agent Framework is designed to aid in the development of dynamic distributed system with “intelligence”.
The Ronin Framework introduces a hybrid approach that is based on the composition of the agent-oriented and service-oriented programming design.
Task 2: Merging agent with Jini
Ronin Design Goal
Promote generic agent attributes. Making knowledge sharing possible. Making basic communication negotiation
possible. Independent ACL and network protocol. Making the integration between heterogeneous
agents possible. Simplicity.
Ronin Design
The Ronin Agent Framework defines an open framework that specifies the infrastructure requirements and interface guide line for the agent interaction and communication.
The standard interface and classes that are central (“core”) to the Ronin Agent Framework is called Core Ronin Agent Framework.
Core Ronin Components
Envelope– A meta container for ACL messages.
Effect.– Provides an uniformed structure for delivering
messages. – No network protocol restriction is imposed.
Core Ronin Components
Common Agent Attributes.– Describes agent features to distinguish one agent
from another in ways that are domain independent.– The attribute types and semantic meanings are
defined by Ronin in the domain independent fashion.
Effect– Allows agents to find each other in a domain
independent way, using the generic agent attributes.
Ronin Components
Domain Agent Attributes.– Describes agent features to distinguish one agent
from another in ways that are domain dependent.– The framework does not define the types and
semantic meanings of the Domain Agent Attributes. Effect
– Allows agents to find each other using the domain knowledge as an alternative to the common agent attributes.
Ronin Agent.– A specialized version of a Jini service with the
agent-oriented abstraction. – Provides services through agent communication.– Can be realized by either hardware or software.– Required to have at one Agent Deputy if it is
intended to be contacted by other agents.– Required to have a set of Agent Attributes and
Agent Domain Attributes.
Core Ronin Components
Core Ronin Components
Ronin Agent Deputy.– A specialized version of a Jini service proxy object. – Responsible for handling the communication and
the interaction between its owner Ronin agent and other agents in the system.
Core Ronin Components (Agent Deputy Cont.)
Effect– Provides a local agent representation. – The mobile front-end of the agent.– Hides the actual agent implementation from other
agents. – Making flexible and robust agent communication
possible. Using store-and-forward mechanism. Mailbox mechanism and more …
Proxy Object
An object diagram of a proxy structure at runtime.
Client Proxy Print Server
Core Ronin Components
Ronin Agent & Agent Deputy– Ronin agent owns one or many Agent Deputies. – Agent Deputy will register with Lookup Service
along with Agent’s attributes.– Agents communicate with other agents through their
Agent Deputies.– Agent Deputy is responsible for choose the right
communication scheme to delivery messages back to the owner agent.
Core Ronin & Ronin Implementations
Core Ronin only defines interfaces and classes that are needed to get things to run.– The idea is similar to net.jini.core
Ronin Implementation ~= com.sun.jini Core Ronin has 3 packages
– edu.umbc.ronin.attributes– edu.umbc.ronin.deputy– edu.umbc.ronin.language
Core Ronin
Agent Group Ronin Implementation
Feature.– Ronin Agent/Jini Service Shell (template).
Jini join & lookup specific information can specified in a Java Properties.
Dynamically initialize Agent Attributes and Domain Attributes based on Properties file.
– Provides sufficient library for implementing agent-oriented Jini services.
– Guarantees that deploying Ronin agents is not harder than deploying traditional Jini services.
Agent Group Ronin Implementation
5 Packages– edu.umbc.agent.ronin.agent
Ronin Agent Shell and Message Dispatching utilities.
– edu.umbc.agent.ronin.deputy AND edu.umbc.agent.ronin.deputy.transport
Out-of-box Agent Deputy implementation.
– edu.umbc.agent.ronin.lookup Customzied Lookup Tools for finding Ronin Agents.
– edu.umbc.agent.ronin.util Ronin Agent Shell Admin tools and misc. tools.
Out-of-box Agent Deputy
Receive Remote Envelope
A Smart Jini System
We have developed a distributed system based on the Ronin framework and DPKB to demonstrate their feasibility.
The system is called Agents2Go.
Agents2Go
Components in the system:– An user with a PDA.– A Broker Agent.
Capable of making recommendations to users on local restaurants information.
– A DPKB service.– A number of restaurant agents.
Provides dynamic information about the restaurant, e.G. Wait time etc.
Agents2Go
PDA finds the Broker Agent through Jini lookup service.
PDA submits recommendation request to the Broker with constraint and personal profile attached.
Broker preprocesses the request, constraints, and profile info, and then converts them into a number of queries in Prolog. It depends on the DPKB service for knowledge representation and reasoning.
Agents2Go
If the Broker KB does not have sufficient knowledge to make a recommendation, then the Broker will try to discover and lookup local restaurant agents through the Jini lookup service.
Broker negotiates with these agents using descriptive agent communication language, KQML. Message content is expressed in Prolog.
Agents2Go
After the Broker has received enough information, it restarts the recommendation inference process.
Broker replies the original request with the recommendation. The reply is expressed in the format that can be understood by the PDA.
Screenshots
Netform is a Palm application.
Netform allows a user to find his/her favorite restaurants.
Screenshots
User can specify various matching attributes.
We are looking for – Japanese cuisine– Has dinning in– Has reservation– Price range between $10
and $20.
Screenshots
Making connection to the network.
Connecting the proxy on the network.
The proxy is responsible for contacting agents in the system.
Screenshots
A matched result is send back from the proxy.
Future Works
Make the specifications and the source code of Ronin framework to be available to the community.
Use BeamML for constructing Agent Deputy dynamically.
Add support for Java Servlet.
Conclusion
Java + Jini provides an excellent platform for developing distributed system.
Java + Jini + Agent provides an excellent platform for developing intelligent distributes system.
Ronin framework provide a flexible and robust development platform for building dynamic distributed system with “intelligence”.
More Information
Harry Chen– University of Maryland Baltimore county– Email: [email protected]
Related project and URL– Dynamic Negotiating Agents (DNA)
http://www.cs.umbc.edu/dna
– Agent Web http://www.cs.umbc.edu/agents