Implementation of Agent-based Ontology Mapping ... - Semantic Scholar

Implementation of Agent-based Ontology Mapping and Integration Li Li

Baolin Wu

Yun Yang

Faculty of Information and Communication Technologies Swinburne University of Technology PO Box 218, Hawthorn, Melbourne, Australia 3122 Email {lli,bwu,yyang}@it.swin.edu.au

Of the architectures of modelling ontology managements (including ontology mapping and integration), most of the existing work attempt to build systems by using specific techniques to define similarity measurement, or to solve problems such as matching in ontology mapping rather than focus on architectures. For example, GLUE (Doan, Madhavan, Domingos & Halevy 2003) used machine learning techniques. FCA-Merge (Stumme & Maedche 2001) used formal concept analysis (Ganter & Wille 1999). Others attempted to provide tools for designers/users to facilitate ontology mappings. For instance, PROMPT (Noy & Musen 2003) suggests designers which concepts may be related. Only little of existing systems or tools claim that they have considered architectures and supporting techniques. In which InfoSleuth (Fowler, Nodine, Perry & Bargmeyer 1999, Nodine, Fowler, Ksiezyk, Perry, Taylor & Unruh 2000), an agent-based system, is worth noting. It is implemented in Java, and the agent communication language is KQML (Finin, Fritzson, McKay & McEntire 1994). However, as stated in its future work, it lacks important capabilities such as managing agent systems as provided in some current agent softwares. Moreover, it is not FIPA-compliant. On the other hand, it has no intention to create mapping automatically in the proposed system. In principle, a distributed and dynamic environment such as the Web requires a scalable architecture with all its components interactivity to respond in a timely fashion. In other words, it requires a reactive system rather than only a functional system (Wooldridge 2002) in which other processes in the environment can “interfere” with the actions that the same process attempts to perform. Essentially, the interference of actions of other process is out of control of this process. In this sense, we can not expect that existing systems and tools, which mainly treat the environment static along with much prior knowledge required, are suitable and feasible in the dynamic environment. Although the problem of specifying the architecture is at the core of ontology mapping and integration on the Web, it has not been thoroughly investigated yet. It is a great challenge to design an architecture which performs corresponding operations as flexible as possible. To achieve the flexibility, agent technology finds its niche in operating over heterogeneous ontologies in a dynamic and distributed environment where substantial support for change is necessary. The use of agent technology provides a high degree of decentralisation of capabilities which is the key to system scalability and extensibility. Hence, an multi-agent system (MAS) approach is suitable in tackling ontology mapping and integration in an open environment. This paper is organised as follows. Section 2 introduces an overall agent-based architecture. Section 3

Abstract Globalisation of business environments on the Web has given rise to the advent of a variety of ontologies which are far beyond expectations. The achievement of some goals requires more than individual capabilities and knowledge. Hence, it is necessary for different organisations to work with others in order to achieve the goals. In this paper, an innovative agent-based architecture is developed to model ontology mapping and integration in a distributed and dynamic business environment where interactions among organisations may take place at unpredictable times, for unpredictable reasons, and between unpredictable organisations. Functionalities and implementation of involved agents are discussed. In addition, a three-layer user ontologies are introduced. Finally, demonstrations of ontology mapping and integration are presented. Keywords: Agent-based architecture, ACL, ontology mapping, ontology integration. 1

Introduction

Ontologies facilitate the interoperability between heterogeneous systems involved in commonly interested domain applications by providing a shared understanding of domain problems and a formalisation that makes ontologies machine-processable. The benefits of using ontologies have been recognised in many areas such as knowledge and content management, and e-commerce. Unfortunately, an ontology is not a solution for all unless everyone adheres to the same one. Practically, it is unlikely to happen, given the proliferation of Internet technology and globalisation of business environments. Frequently, in business, achievement of some goals requires more than individual capabilities and knowledge which makes it necessary for different organisations to work together in order to achieve the goals. On the other hand, the proliferation of Internet technology and globalisation of business environments has given rise to the advent of an ever-surprising varieties of ontologies which are far beyond expectations, whilst the changeable environment enforces underlying ontologies evolving over time. Moreover, interactions among organisations may take place at unpredictable times, for unpredictable reasons, between unpredictable organisations. Agents in multi-agent systems (MAS) operate flexibly and rationally in an environment which are dynamic and heterogeneous, given that agents have abilities to perceive changes of environments and respond in a timely fashion. A MAS perspective is thus suitable for modelling ontology mapping and integration within and across the boundaries of organisations. The aim of this paper is to develop a novel agent-based architecture to model ontology mapping and integration.

1

proposes agent designs and implementations. Section 4 discusses ontologies in this work. Section 5 demonstrates ontology mapping and integration together with verification, evaluation and lessons learned. Section 6 contains overviews of the related work and discussion. And finally, Section 7 is conclusions and future work.

thesaurus agent

user agent

Agent-based Architecture

Agent technology presents an exciting prospect in a field where high dynamics are requested. It has the potential to significantly extend the range of applications that can feasibly be tackled (Jennings & Wooldridge 2001). 2.1

mapping agent

integration agent

checking agent

query agent

interface agent ontology agent

ontology agent

ontology agent

ontology agent

ontology agent

wrapper

wrapper

wrapper

wrapper

wrapper

Frame-based

RDF

DAML+OIL

OWL

OIL

li brary of com mon know ledg e

2

functionary agents

Figure 1: Agent-based framework a variety of environmental circumstances, given the abilities to perceive changes of the environment and respond in a timely fashion. MAS’s abilities of providing robustness and efficiency and solving problems in which data or control is distributed, make the MAS perfectly suitable for dynamic, distributed environments. Agent technology is thus ideally suited to model ontology mapping and integration on the Web.

Rationale

The emergency of the Web has made the environment of ontologies and ontology-based applications change rapidly, which also has made ontology integration more difficult than ever before. In order to identify the characteristics of problems, let us take a closer look at ontologies and ontology-based applications over the Web. The followings are the characteristics of the environment:

2.2

Agent-based Architecture Overview

The overall framework of the agent-based ontology management is shown in Figure 1 (Li, Yang, & Wu 2005). The functionalities of each agents in this environment are briefly described below. Detailed descriptions are given in Section 3. User Agent (UA): This agent interacts with a particular GUI. It includes getting the business scenario from GUI, passing it on to the interface agent (IA) and presenting expected results. Interface Agent (IA): This agent interacts with the UA. It is in charge of assigning a particular task to one or several agent(s) of a virtual community1 . Ontology Agent (OA): This agent acts on behalf of a certain ontology. It behaves properly in a specified agent platform. It is equipped with functionalities of a certain ontology (e.g. it operates over the ontology structure and a particular intermediate result structure). The main purpose of the OA is to perform ontology related tasks which are isolated from external functionary agents. The presence of OA allows flexible system organisation. Functionary Agent: It consists of agents providing functionalities of thesaurus similarity, ontology mapping, ontology integration and consistency checking. They are described next.

• Available ontologies are scattered on the Web which makes manually gathering of relevant information for a particular problem nearly impossible; • The number of organisations (with different ontologies) may change dynamically by organisations entering or leaving the environment randomly. Furthermore, which ontology is available along with a particular organisation is uncertain; • Ontologies are prone to adaptation and evolution; • Processes of different organisations operate concurrently to modify the environment in ways that an organisation has no control over; • Different organisations demand efficient interaction as these interactions may occur at unpredictable times, for unpredictable reasons, between unpredictable organisation. An organisation thus needs to consider synchronising or coordinating its actions with those of other processes in the environment. In short, the typical characteristics of ontologies and ontology-based applications on the Web can be identified as: distributed (namely ontologies scattered in different places), non-deterministic (in practice, almost all realistic environments must be regarded as non-deterministic), heterogeneous (ontologies may have various modelling methods and different representations), and highly dynamic (the number of organisations/ontologies keeps changing, the ontology is evolving over time, with many processes concurrently to modify the environment in ways that an organisation has no control over, heterogeneous systems need to interact by spanning organisational boundaries and operating effectively within changing environment). However, existing systems or tools in this field so far have been treated mainly as being static, so it is unlikely they can tackle ontologies and ontology-based applications efficiently and effectively in the above environment. From a multi-agent system perspective, agents in MASs are autonomous and flexible with major characteristics of reactivity, proactivity and high interactive ability (Wooldridge 2002). MASs are able to operate flexibly and rationally in

• Thesaurus Similarity Agent (SA): It is in charge of maintaining thesaurus similarity within a suitable structure. The major tasks of the SA are to: (1) append new concepts to the specified structure; and (2) search a particular concept in the structure. • Mapping Agent(MA): It is shaped to provide linkages to pave the way for the interoperability of heterogeneity of various ontologies on the Web. It is the foundation of further ontology integration. The major task of the MA is to estimate whether two given concepts mapping each other according to its knowledge. • Integration Agent(InA): It is responsible for ontology integration based on a certain business scenario. The major tasks of an InA are to: (1)count the appearance of each specified concept; and (2) filter the unexpected items before sending them to the OA. 1 A group of partners commonly interested in a certain business scenario.

2

is to convey information about an agent’s own mental state with the objective of affecting the mental state of the communication partner. As some kind of shared ontology is the foundation in agent communications, we build an ontology with respect to accessing ontology structure (below in Section 4, we name it meta-ontology). Following FIPA ACL (http://www.fipa.org/repository/aclspecs.html) communicative acts (http://www.fipa.org/repository /cas.php3), a three-layer model of FIPA ACL includes the content (layer) of the message; the message (layer) of particular attitude towards the content in the forms of performatives of ACL (Wooldridge 2002); and the communication (layer) of mechanics of communication. The concrete syntax for FIPA ACL messages closely resembles that of KQML, but the ACL language has greatly enhanced the semantics of passing messages.

goal G agent

i

message M

agent j

intent I speech act

msg M convert to transport form

convert to transport form

message delivery / transportation service

Figure 2: Message passing between agents from FIPA communicative act library specification • Consistency Checking Agent (CA): It checks the consistency of an ontology. The major tasks of a CA are to: (1) check if a particular concept is the subclass of two disjoint concepts; and (2) warn the UA if inconsistency exists. • Query Agent(QA): It is in charge of a query based on created ontology mappings between pairs of ontologies. It maintains the query module in a distributed environment.

2.4

Agent Interaction

At an abstract level, agents achieve a goal by working with other agents to solve problems that are beyond individual capabilities and knowledge. Below, Library of Common Knowledge: This library we demonstrate a scenario of interaction among the includes atomic roles and primitive concepts which agents in the ontology mapping module. comprise the baseline of knowledge in a particular doUpon initialisation, interface agent (IA) obtain relmain. It may initially be created or become created evant information of registered agents. A user comduring run time through agent communications. mences interaction with the systems by means of a Wrapper programs, attached to each ontology particular user interface. Suppose that the user sources, handle ontology formatting transformations poses a mapping in the scenario, the user agent (UA) between the local representation model and the interforwards a request to the IA. On receiving the request, nal representation model of the proposed system. the IA routes it to appropriate agents (e.g. MA) to fulfill the required tasks. As mapping is executed be2.3 Agent Communication Languages tween pairs of ontologies, the MA contact a pair of specified ontologies with respect to needed informaAt an abstract level, agents achieve a goal by tion from corresponding ontologies. The MA needs to working with other agents to solve problems that work with thesaurus similarity agent (SA) from time are beyond individual capabilities and knowledge. to time for similarity measurement of current inforAgents work together based on interactions. ACL mation. The MA takes a proper mapping module to is FIPA agent communication language which is execute by consulting corresponding OAs. The MA based on communicative acts of speech act theory (http://www.fipa.org/specs/fipa00037/SC00037J.html). then writes to a mapping file. Mapping result can be accessed by OAs. After the mapping comes to a It is treated as an agent communication language completion, the mapping results will be returned to outweighing KQML (Finin et al. 1994) in which the the UA via the IA, which then visualises the results semantics of ACL is rigorously defined. An ACL is a to the user interface for display. set of primitives (e.g. performatives) that allow an For simplicity, the interactions among the MA and agent to state its intention to achieve by exchanging specified OAs are in brevity. In the following, intermessages between agents. action diagrams will be introduced to describe interACL is an outer language that specifies message actions among agents for a particular task. format and include descriptions of their pragmatics, that is the communicative acts or intentions of the agents. ACLs are merely message formats as well as 3 Agent Design and Implementation an “instruction” to describe an agent’s intention in the communication. It allows flexibility on designing In this section, the interrelated processes and autonomous and heterogeneous agents as the ACL functionality together with its implementawithout a fixed semantics. That is why multi-agent tion of each agent in the JADE agent platbased systems often implement subsets of the perforform2 (http://jade.tilab.com/) are presented. JADE matives of the ACLs (http://infoeng.ee.ic.ac.uk/ mais claimed to comply to FIPA (http://www.fipa.org) likz/surprise2001/hsh99e/article1/). specifications. Communicative acts is based on the speech act theory (http://www.fipa.org/specs/fipa00037/SC00037J.html), 3.1 User Agent in which agents have, amongst their mental attitudes, The UA assists the user in formulating its requests the following: some goal G and some intention I. posting queries (e.g. tasks) to the proposed system Assume that individual agents can not carry out via the IA, and in visualising the results of required the intention by themselves. If agents are behaving tasks according to the user’s requirement. It seperates rationally in some reasonable sense, they will contact complex internal system designs and implementations other agents which will satisfy the intention and thus from the user. During initialisation, the UA waits for achieve the goal at the end (Figure2). information from the user interface. The UA must Agent communication language is FIPA ACL. In engage in “communications” with the IA in fulfilling essence, an agent communication language provides 2 Refer to the website (http://exp.telecomitalialab.com/) for a set of communication acts for agents in a MAS more details of why JADE is a suitable technical platform for modto perform. The purpose of agent communication elling distributed and heterogeneous environments. Refer to the website (http://www.agentlink.org/) for available agent softwares.

3

its role because the internal structure is invisible to it yet. The UA only knows the IA. The UA knows nothing about other agents created in our multi-agent system environment. The agent interactions only take place between the UA and IA. See the following descriptions of other agent interactions. The UA waits for actions from the user interface then sends an ACLMessage to the IA when it has received a user action. For example, if a user is in the mapping interface, chooses two agents then clicks OK to execute mapping module, the user interface passes the agents to the start mapping method in the UA. The UA does not know how to map but it creates an ACLMessage and adds the two ontology agents as parameters in the ACLMessage and sends this ACLMessage off to the IA. When information is to be displayed to users, the IA passes a message back to the UA which will show necessary results on the user interface. 3.2

UA

IA Functionary agents request for a certain functionality

Ontology agents OAi

OAj

request send a request to a particular OA

request inform inform request request

Figure 3: Interactions of the ontology agent(OA) - Traverse, namely traverse the structure, return the requested concepts or “True/False” of a given proposition. • operations over the mapping results - Append, namely append the mapping results into the mapping result; - Search, namely search the map.file.

Interface Agent

The IA acts as an interface between agents in our created multi-agent systems and the UA. Upon initialisation, every agent knows about the IA. So if any other functionary agent, for example, the MA, wants to show mapping results to the user, it can send a message to the IA which will pass it on to the UA to display. On the other hand, when new agents, for example OAs, are added in, the IA will let all other agents know. So existing agents may refer to newly added agents. The IA facilitates the modularity of the MAS environment. It is involved in all sorts of tasks when communications between created agents (e.g. a multiagent system) and the user interface are required. The IA receives messages from the UA then based on the conversation id of the ACLMessage, it passes it on to the appropriate agent in our created multi-agent system to deal with. For example, the IA may receive a message from the UA with the conversation id of “start-mapping”. The IA does not know anything about mapping but knows when it gets this message to pass it on to the mapping agent to handle. The mapping agent will then extract the content of the message and perform mapping on these two OAs.

An OA’s main responsibility is to look after an ontology, either the one imported from a RDF(s) file or the one created in an object oriented way. OAs are all equipped to be able to perform some functions to reify agent behaviours responding to certain coming ACLMessages. The OAs are not added to JADE at start up. They are added to our current running container when the user presses the run button in the user interface. Assuming that the user wants the system to add two OAs, for example, beer1Agent and beer2Agent. When these agents first enter our system, they register themselves with the IA. All agents will have a reference to these two added OAs via the IA.

3.3

3.4

Besides, OAs act properly when triggered by different sources of driving forces. For example, in a query module, an OA will dispatch a particular query request to other known OAs if it is unable to answer the query. Next, we focus on ontology mapping related interactions, by taking into account the interactions between the OA and MA, and the OA and QA as well.

Ontology Agent

Thesaurus Similarity Agent

The SA maintains a thesaurus for the purpose of similarity. Upon initialisiation, it waits for information from either a functionary agent or the UA with respect to query or update the contents in the thesaurus. It then returns the result to the corresponding requesters. The SA may work in two cases by interacting with other agents (Figure 4). One is during mapping module when the MA is looking for synonyms of a given term from an ontologies if the MA have found no such concept in another ontologies. Another case is when a user asks to update the thesaurus list. The SA holds a list of common words and synonyms of words. For example, during the mapping process, if the MA is trying to perform mapping on two ontologies, and gets the concept suds from one ontology, and wants to map it to another ontology, but that ontology has no concept called suds, then the MA sends an ACLMessage to the IA. The IA reads the conversation id of this message and passes it on to the SA. The SA then looks in its list and gathers a list of synonyms for the particular term. The SA then sends this list back in an ACLMessage to the IA, which passes it back to the MA. The MA will then use this list for mapping.

The OA provides an ontology related information and operations to other agents. The OAs isolate details of external ontologies(e.g. different ontologies) from functionary agents. Upon initialisation, it waits for information from other agents. It engages in “communication” with these agents with respect to the required information. This process may loop until the module runs out of concept candidates of a specified ontology. The OA may return a result to the user via the IA and the UA. The OA provides as much information of the ontology it acts on as possible by interacting with other agents (Figure 3). The OA operates over two structures: (1) the ontology structure (e.g. the ontology it acts on behalf of); and (2) the mapping results. The major operations on these two structures are as followings. • operations over the ontology structure - Insert, namely insert a new concept into the ontology structure, the UA may specify where to attach the concept (for ontology integration phase); 4

UA

IA

MA

SA

SA

OA

MA OA i

request mapping

OA j

request get_current_node

request syn_search search syn.file

not-known

inform current_node

traverse the ontology structure to get the current node

inform synoynm

check

R1

request (append to syn.file) agree (append to syn.file)

append to syn_file

request insert to map.file insert mapping result into map.file

request synonyms

R2

inform synonyms

request insert to map.file

Figure 4: Interactions of the thesaurus similarity agent(SA)

request attr

R3

insert mapping result into map.file traverse the ontology structure to get the attributes of the current node

inform attr

UA

IA

MA

request insert to map.file R4

request mapping

request insert to map.file

request mapping

inform-ref ask for the value of “domain”

insert mapping rules into map.file

inform-ref ask for the value of “domain”

insert mapping result into map.file

Figure 6: Interactions of the mapping agent(MA)

no yes

refuse

Upon initialisation, the InA waits for the action of performing integration over specified ontologies. The InA then engages in “communications” with proper OAs until the integration task has been solved. Integration module executes integration from a given start point of an ontology. It then requests corresponding OAs to traverse sub-concepts of the ontology. Briefly speaking, InA counts the appearance of each concept of existing ontologies, and then filters unexpected concepts with a given threshold. By saying this, we do not mean that we attempt to change the conceptual modelling of the ontology. Instead, ontology integration is based on a specified ontology. The process (shown in Figure 7) looks like: (1) obtain ontology related information via OAs (e.g. access mapping files); (2) keep the numbers of occurrences of each concept in the specified ontology; Three cases may take place according to the mapping results. They are:

Figure 5: Module of deciding the domain 3.5

Mapping Agent

Dynamic mapping is thought as on the right track to pave the way for further ontology operations. The MA takes effect on receiving a mapping request from the UA via the IA. It engages in “communication” with OAs and the SA to execute mapping until the process completes. OAs will have a reference to the mapping results. Unlike the OA or other agents, the MA does not operate directly over existing structures. It takes effect via the IA in the module (Figure 5) in deciding whether existing ontologies come from the same domain or not; or in the module of ontology mapping (Figure 6) through the OA and the SA to acquire relevant information. The former module paves the way for deployment of predefined rules (actually, these rules are the required little prior knowledge) In reality, the process of deployment of rules may loop until it runs out of sub-concepts of a specified ontology. Mapping is conducted from a particular OA’s perspective. In other words, mapping has directions. The MA performs mapping on pairs of ontologies and writes the mapping results out to a mapping file. To illustrate the entire process, assuming the user inputs two ontologies. The user interface then sends these two ontology names to the UA which wraps them up in an ACLMessage and passes it on to the IA. The IA will pass the message on (based on conversation id) to the appropriate agents to handle. 3.6

• Case 1: semantic equivalence for the current two concepts (for example, “beer” is the same as “suds”): In this case, increase the number of occurrences of the concept by 1 for each equivalence; • Case 2: inclusive relation for the current two concepts (for example, “stout” is a kind of “ale”): In this case, insert sub-concepts of the counterpart into the specified ontology structure but keep the original relations; • Case 3: no semantic equivalence for the current two concepts but their corresponding direct ancestors are semantically equivalent: In this case, insert the counterpart into the specified ontology but without conflict with existing sub-concepts of the same ancestor;

Integration Agent

ontology integration is based on the results of ontology mapping. It is from a particular agent’s perspective. In other words, the system has no intention to be engaged in conceptual modelling issues (e.g. how to build an ontology), instead, it uses the existing conceptual models by choosing one (by the user) of them. The purpose of integration is to extend, enlarge, or refine a certain ontology from a global view.

(3) filter unexpected concepts by a given threshold. The InA performs integration of the ontology agents. To illustrate the entire process, we take the example below. When the user wants to integrate the ontologies they provide the dominating ontology, and a threshold. The user interface passes this information on to the UA which wraps it up in an ACLMessage and sends it to the IA. The IA looks at 5

UA

OA new

OA

InA

IA

OA j

OA i

QA OA i

OA OA k

OA j

request start_node search map.file, if they are the same, then increase the counter by 1

traverse the ontology structure to get the current nodes

inform current_node

request term

draw edges to link reachable ontologies

request subs inform subs

inform where [N]

create a new ontology

visualisation

Interactions

of

IA

the

CA

integration

[N]

consistent

Query Agent

The QA is designed to govern query execution around available OAs over the mapping results. The query aims to provide an equivalent description of queried term if the agent knows it. If not, the agent then passes the query to other available OAs. The query dispatching module is continuing until either the query is answered or the process has queried all existing OAs with respect to the term. The result (e.g. a query routing) is displayed on the user interface. Upon initialisation, the QA) waits for actions from the user interface to perform the query. The QA then executes the query module by engaging in “communications” with OAs with reference to mapping results. This process completes when the queried terms is interpreted. The query agent acts like a planning agent for a reachable path in a decentralised ontology network. It is responsible for tasks such as keeping tracks of OAs in case of backtracking is required (Figure 9). The QA gets a ACLMessage from the IA to query an ontology of a specified term. For example, when the user inputs the query term and the ontology to query, the user interface will pass the query term and the ontology to the UA which will wrap up this information in an ACLMessage and send it to the IA. The IA will look at conversation id of the message and realise that it needs to send it to an OA itself. So the IA will unwrap the message to determine which agent it needs to send it to. The IA then sends the ACLMessage to that OA. Each OA has been programmed to handle this kind of message. So when an OA receives this message, it searches through its own ontology for the query term. If it is unsuccessful, it then searches through appropriate mapping files. It will then pass a result message back to the IA, which will pass it on to the UA. Then the user will see a message posted on screen either something like “suds = agent1.beer” or “no semantic equivalence”.

OA request information

execute checking module

traverse ontology

return result

inconsistent

Figure 8: Interactions of the consistency checking agent(CA) conversation id of this message then passes it on to the InA. The InA will request the ontologies from available OAs (this is done again by ACLMessages). When the integration module has all the ontologies (by contacting OAs), it performs integration module based on the dominating ontology, the threshold, and of course the mapping results. When the integration has been done, the first thing is that an OA is created on the fly which will look after the newly integrated ontology. Then the InA sends the new ontology to the IA in an ACLMessage. The IA then passes it on to the UA which will display the new ontology to the user in a tree view. The user can later exports this new ontology to a RDF(s) format. 3.7

search map.files

an ontology. It sends a message back stating that inconsistency or no inconsistency was found, which will eventually be passed back to the user interface. 3.8

request checking

visualise

search map.files

Figure 9: Interactions of the query agent(QA) request insert into the new ontology

inform threshold

UA

[N] request term

inform where [N] inform result [Y]

request UA a threshold

Figure 7: agent(InA)

inform where [N] inform result [Y]

[N] request the term

request is_sub inform [Yes|No]

search map.file, if they are the same, then increase the counter by 1

search map.files

inform result [Y]

Checking Agent

The CA is developed to check the consistency of integrated ontology (assuming all provided ontologies are consistent). Upon initialisation, the CA) waits for actions from the user interface to perform consistency checking task upon a generated ontology. The CA then executes checking module by engaging in “communications” with a particular OA. This process may loop until no candidate concept from the ontology left. When the CA initialises, the CA waits for a request to perform checking task over a specified ontology. It then engages in “communications” with a particular OA to operate the checking module. It returns the user either (a given ontology) consistent or not. If the ontology is inconsistent, the problem part of the ontology is highlighted in the user interface. The whole process is shown in Figure 8. When the checking button (to check the consistency of integrated ontology) of user interface is clicked, the user interface passes this information on to the UA. The message is wrapped up in an ACLMessage and sends to the IA. The CA gets a ACLMessage from the IA to check the consistency of

3.9

Important Notes

All our agents make use of JADE Message Templates in order to perform certain tasks based on certain attributes of the message. For example, an OA can send concepts. When the OA receives a message, it needs to determine which of these behaviours to execute. The way we do this is by using Message Templates. Message Templates allow us to filter messages based on attributes like performative type, conversation id, and sender, etc.

6

4

Ontologies entity

The purpose of this work is to develop a flexible system for agents, which consume ontologies usually, engage in ontology management such as ontology mapping and ontology integration. An agent, if it works with some other agents, clearly needs some kind of ontologies to communicate with others to know the meanings of the content expressions. Moreover, with some kind of ontologies, the agent is able to verify that messages it receives are meaningful piece of information. Those messages comply with specifications of the agent ontologies (distinguishing from user defined ontologies. Herein, “agent ontology” is denoted as internal ontologies, while “ontologies” represent user defined ontologies) by means of which both the sender (agent) and the receiver (agent) agree upon a proper meaning to the messages. In addition, there are various user defined ontologies with different representations. These ontologies come from different sources (organisations in business). When cooperation among agents is called in, ontology- understandable must be solved first. As this work is focused on using agent technology in handling ontology related management, we would rather highlight operations over ontologies on a given content expression of an ACL message. As for the “agent ontology” is the ontology of operations over the user defined ontologies, it can be called meta-ontology intuitively. Descriptions of user defined ontology and some relevant terminology are given in the following section. 4.1

label type attribute

Object Layer

ontology

concept

is-a

concept Ontology Layer

Figure 10: Three-layer ontology model class) are defined for ontology and agent generation on the fly. In the prototype, different ontologies, for example RDFs ontologies, are created for demonstration. Correspondingly, different kinds of agents are generated. Among them, there are user agent (UA), interface agent IA), ontology agent (OA), and functionary agents. In the following, two major operations will be demonstrated in detail. 5.1

Ontology Mapping

Since work together in a business environment is necessary and inevitable, it is asked that agents should be able to understand each other no matter what languages or representations used. Dynamic ontology mapping is seen as a feasible and effective approach by means of ontology interoperability. In the work, mapping attempts to provide mapping results for any further ontology operations, for example ontology integration. Mapping is operated from a source ontology to a target ontology (e.g pairs of ontologies), so the mapping results are stored locally associated with the source ontology agent. In other words, only this OA can access and update the result. The mapping module in the prototype runs as follows: (1)Import existing ontologies; (2)Develop corresponding OAs for each available ontology; (3)Develop corresponding functionary agents (e.g MA); (4)Execute the mapping module. The above mapping module may start from the top most of ontologies, it also may starts from particular parts of ontologies. It may loop until it runs out of concepts of ontologies according to a scenario.

User Defined Ontology

5.2

Ontology Integration

Figure 11 is the screen shots of the ontology mapping and the mapping process. The screen shot at the back is an overall prototype when the “mapping” button is clicked. The lower left screen shot is a mapping screen where the mapping direction is specified in addition to two given ontologies. The mapping result in plain text is shown in the lower right of Figure 11. Ontology integration is based on ontology mapping results in order to provide a global view of existing ontologies in the environment. Since ontology conceptualisation is out of the scope in this work, we will not extend this topic any more but instead to choose one available ontology to perform ontology integration. The prototype runs as follows: (1)Import existing ontologies;

User Defined Ontology in the System

When an ontology is imported to the system, an OA is automatically developed to act on behalf of this ontology and to perform ontology related operations such as access and update the ontology. Other agents, for example functionary agents, can not access individual ontologies. 5

E-R model Layer

id

A three-layer model (Figure 10) is developed to represent user defined ontologies in the system. This model allows different ontology languages and representations when instantiating various ontologies. The three layers are: E-R model, object, and ontology. The top level E-R model is a general model in modeling the reality at an abstract level. It is in accordance with Gruber’s best known ontology definition (Gruber 1993) where an ontology is an explicit specification of a conceptualisation. An ontology is a specification, namely a pair of < Σ, Ψ > to describe that Σ satisfies the axioms Ψ derived from a domain model, where a conceptualisation Σ is a pair of < C, R > with C representing a set of concepts, and R standing for a set of relations over these concepts. Below the E-R model layer is the object layer where “id”, “label”, “attribute”, and “type” are defined. Objects in this layer are instances of E-R model layer classes. The bottom layer is the ontology layer. Various ontologies of the system are instantiations of objects in the object layer. A prominent feature of the ontology in this system is the “attribute” of an “entity” or a “slot”. It is defined to take both simple data type and complex type such as the class type as well. 4.2

entity

R

Prototyping

The JADE agent platform is used to build the MAS system. To meet the main tasks of the work, different classes (e.g. concept class, ontology class and agent 7

conducted from a particular OA’s perspective. When there is a mapping from one ontology to another, the query module draws an edge to link these two vertices together with a direction. In the end, a directed graph is obtained. Clearly, it is a weakly connected graph4 (see Figure 13 for example). We believe that a query can be done by a query module given the graph is weakly connected. Below are representative examples. For simplicity, q(OAi , x) is for query(OAi , x), where i ∈ [1..4], x the content of query, and OAi the agent who acts on behalf of existing ontology (e.g. Oi ). ct (t ∈ N) represents a concept in an ontology. In this example, dispatching a query from OA1 to OA2 is denoted as OA1 −→ OA2 , and the path is denoted by the vertex number in a form of 1 −→ 2 if vertex 2 is reachable from vertex 1. Suppose the initial state is: q(OA1 , c4 ). The query module is conducting as follows:

Figure 11: Screen shot of ontology mapping

Case 1 (Figure 13(a)): the query can be executed via OA1 because of a direct edge from O1 to O4 , i.e. no need to dispatch the query to any other agents;

Figure 12: Screen shot of ontology integration

Case 2 (Figure 13(b)): since no such kind of mapping exists, the query module may dispatch a query to any agents associated. In this case, the optional agent set is {OA2 , OA3 }. The process is as follows: If OA1 −→ OA3 , it is settled. The path is 1 −→ 3 −→ 4; If OA1 −→ OA2 , then another dispatching (e.g. OA2 −→ OA3 ) is needed. Moreover, as the mapping direction is from O3 to O2 , the corresponding agent (e.g. OA2 ) needs to reverse the mapping results. After it is settled, the query is done. The path is: 1 −→ 2 −→ 3 −→ 4. But the best path is: 1 −→ 3 −→ 4 in this case.

(2)Develop corresponding OAs for each available Case 3 (Figure 13(c)): because no direct connection beontology; tween O1 and O4 , the module will follow the pro(3)Execute mapping module; cess: OA1 −→ OA2 −→ OA3 . The best path is: (4)Execute integration module; 1 −→ 2 −→ 3 −→ 4. (5)Visualise the integrated ontology. The user may choose to export the integrated onIn any cases, query can always be done given the tology in a specified format (e.g. RDF(s)3 ). graph (mapping) is weakly connected. Figure 12 is the screen shots of the ontology integration framework and integration results. The upper part is the overall prototype when “integration” button is clicked. The lower left part is the integrated ontology in RDF(s) format, while the lower right part is the integrated ontology in the hierarchical structure. 2

1

2

3

4 (a)

1

2

3

4 (b)

1

3

4 (c)

Figure 13: Query in directed graph 5.3

Verification

The verification such as query in distributed ontologies is available in the prototype. For the query module, we deliberately query a particular OA before/after ontology mapping. The experiments clearly show that a particular OA can instantly return corresponding concepts or True/False of given propositions after running the mapping module. As an OA keeps corresponding map.file(s) (Section 3.5) for each pair of ontologies, the OA is certain about the results and can obtain what is requested by dispatching the query to other OAs if it is unable to answer the query. We may regard existing ontologies as vertices, and mapping functions between ontologies (if mappings exist) as edges. As stated in Section 3.5, mapping is

5.4

Evaluation

Ontologies and ontology-based applications perform in the environment of dynamics, distribution and heterogeneity. The agent-based framework proposed in this paper is suitable for tasks such as integrating ontologies in a certain business scenario. By adopting a MAS’s perspective, interactions among multiple agents, which work together to achieve the goal beyond individual capabilities and knowledge, are highlighted. In other words, MASs are able to take a variety of environmental circumstances into consideration rather than treating the environment mainly as being static. The evaluation work takes the following characteristics into account:

3 RDF(s) format is used as connection channel between our prototype and Prot´ eg´ e(http://protege.stanford.edu/). Prot´ eg´ e is an open source ontology editor and knowledge-base framework based on Java. Although ontology building is out of the scope of this work, we expect various ontologies with different representations and languages that can be imported into the system.

4 A weakly connected graph is where the direction of the graph is ignored and the connectedness is defined as if the graph was undirected.

8

because this class already provided us with the functionality of accessing things in a hierarchal structure.

• Flexibility: In the framework, the already set up agent communication channel facilitates message delivery. Moreover, the presence of the ontology agents allows flexible system organisation. The system allows freely adding/deleting ontology agents and functionary agents (including all defined agents for a particular tasks) to/from the system;

(3) Enhancement of JADE From our point of view, maybe JADE could provide two representations of their Ontology class. One for instance level and agent communication, and another for an abstract view to be used to perform certain tasks on the ontology. On the other hand, one thing that needs to be addressed in JADE is that sometimes it is running at the back-end, therefore a method is needed to terminate the program from another program. For example when we are running JADE in our program and close our program, JADE still has a process running. JADE might provide this but we could not find any documentation about it.

• Interactivity: Agents are highly interactive in the framework. Interactions take place not only between ontology agents and functionary agents, but also between functionary agents if a particular task needs to deploy the functionalities of other functionary agent; • Interoperability: The framework enables interoperability between agents of different agent platforms. In terms of syntactic and semantic heterogeneity of ontologies, a meta-ontology is developed to resolve semantic heterogeneities;

6

• Scalability: In the framework, different classes are developed. They include concept class, ontology class and agent class. Moreover, all ontology related operations are encapsulated and isolated from the functionary agents’ visions. By extending corresponding classes, the ontology agent and functionary agent can be created easily.

Existing ontology management systems and tools (excluding ontology building tools) claim they are able to tackle part or some of issues when the framework of ontology management are concerned. Among them, three major classifications can be made according to their designers’ claims. The first one is about using specific techniques or knowledge to facilitate ontology mapping, especially in similarity measurement definitions. Examples are GLUE (machine learning techniques) (Doan et al. 2003), RDFDiff (change-classification rules) (developed jointly by VU Amsterdam and Ontotext Lab), FCA-Merge (formal concept analysis) (Stumme et al. 2001), ONION (articulation rules) (Mitra, Wiederhold & Kersten 2000, Mitra, Wiederhold & Kersten 2001), MAFRA (semantic bridge) (Maedche, Motik, Silva & Volz 2002, Silva & Rocha 2003), and semantic mapping (Li, Wu, & Yang 2005). The second one attempts to provide tools for designers/users to facilitate ontology mappings. For instance, the PROMPT (to suggest designers which concepts may be related) (Noy et al. 2003), OntoMap (to compare ontologies) (Kiryakov, Simov & Dimitrov 2001). The third one introduces architectures as well as matching approaches, for example, OBSERVER (Mena, Illarramendi, Kashyap & Sheth 2000), MOMIS (Bergamaschi, Castano & Vincini 1999, Bergamaschi, Castano, Vincini & Beneventano 2001), and InfoSleuth (Fowler et al. 1999, Nodine et al. 2000). Of all these related work, only InfoSleuth is an agent-based system developed to synthesise new technologies into a unified system that retrieves information with changes of information sources. However, it significantly lacks capabilities such as brokering and monitoring capabilities as strongly supported in the JADE platform. Moreover, it does not comply to FIPA specifications. On the other hand, there is no automation support in creating mappings between ontologies and data schemas in InfoSleuth. In addition to InfoSleuth, the earlier OBSERVER project attempted to aid users to observe a semantic conceptual view of a Global Information System by giving the user the ability to browse multiple domain specific ontologies. In contrast to automatically creating the mappings between ontologies, OBSERVE used an predefined Inter-ontology Relationship Manager (IRM) to provide the translations between terms of different ontologies. In short, although the architecture is at the heart of ontology management in an dynamic environment, it has not been thoroughly investigated yet. Rather than developing the system from the scratch, by taking advantages of both the agent management system

• Reusablity: In the framework, whenever a new ontology is generated based on existing ontologies, an ontology agent is developing correspondingly. It enables the general view of a particular application domain to be reused in the system. • Reliability: It depends on agents performing rationally in the framework. As every agent of the system is required to register and advertise its capabilities to the interface agent, any other agents are able to reach all available capabilities in the system whenever needed. Moreover, the upper bound on the number of iterations (the developed agent algorithms) required to reach a fixed point is the number of concepts in an ontology. It is known that the number of concepts in an ontology is finite. In short, the proposed framework provides a flexible and efficient modelling approach to tackle ontology mapping and integration over a variety of ontologies. 5.5

Related Work and Discussion

Lessons Learned

(1) Problems we encountered from realising the framework by using JADE JADE provides a good platform for developing multi-agent systems but the main problem we encountered was with JADE’s Ontology Class. In our prototype we were mainly looking at performing mapping and integration on two or more ontology’s where JADE’s Ontology Class looks at ontologies only at an instance level which is used for communication purposes between agents. (2) Our solution We came up with a solution but it took significant time to implement. Basically we had to create our own Ontology Class and provide methods that would allow us to change the dynamics of the ontology. For instance we included methods to allow the user to add concepts, sub concepts, add slots to concepts, return concepts, and return slots from a concept. We found the easiest way to do this was to extend Java’s JTree Class 9

on Intelligent Information Integration, Data & Knowledge Engineering, 36(1), pp. 215-249.

(AMS) and the directory facilitator (DF), together with other tools (e.g. Remote Management Agent) bundled with JADE to simplify administration and application development, we concentrate on the overall architecture and functionalities of every kind of agent. The proposed architecture aims to provide the flexibility in dealing with ontology mapping and integration in a dynamic and heterogeneous environment. 7

Castano, S., and Antonellis, V., (1999), A schema analysis and reconciliation tool environment for heterogeneous databases, in ‘Proc. of the 1999 International Symposium on Database Engineering & Applications’, IEEE Computer Society. Doan, A., Madhavan, J., Dhamankar, R., Domingos, P., and Halevy, A., (2003), Learning to match ontologies on the Semantic Web, VLDB Journal, Special Issue on the Semantic Web, 12 (4), pp. 303–319.

Conclusions

This paper discusses agent-based architecture to provide flexible mechanisms for ontology-based applications among distributed and heterogeneous ontologies. We argue that agent-based approach merits ontology interoperability in which it overcomes limitation of existing systems and tools. A variety of ontologies from different sources exist in an dynamic and heterogeneous environment. Existing systems or tools have mainly treated the environment static. Agents in a multi-agent system are autonomous and flexible, given the agents are capable of perceiving changes in the environment and respond promptly. The agent technology is thus suitable in ontology mapping and integration. In this paper, an agent-based architecture is realised by using the JADE agent platform. Each kind of agent has been detailed and implemented in the proposed framework. We also provide a three-layer user ontology model. We have demonstrated how ontology mapping and integration function in the prototype based on the proposed ontology model. We are in the process of extending capabilities of functionary agents by creating more agents to take a role of planning. Currently, a query path can be found if it exists, but no guarantee for an optimal path. With the presence of a planning agent, we expect that an efficient and effective path can always be identified. There are some other directions included as future work. Among them, the semantic match by considering axioms of an ontology is one of the toughest questions. We intend to investigate ontology mapping from an algebraic perspective by treating an ontology as an abstraction in the sense that it can represent any relations with complex structures (axioms). We hope that an algebraic abstraction will allow us to deal with ontology mapping in the same way as wellknown computational metaphors. We also plan to use a process algebra to support agent interactions on a high level of abstraction. We hope that this perspective will allow the proposed framework to deal with tasks among agents in abstract but more flexible ways.

Fowler, J., Nodine, M., Perry, B., and Bargmeyer, B., (1999), Agent based semantic interoperability in infosleuth, SIGMOD Record, 28(1), pp. 60–67. Ganter, B., and Wille, R., (1999), Formal concept analysis: Mathematical Foundations, Springer. Gruber, T. R., (1993), Toward principles for the design of ontologies used for knowledge sharing, KSL-93-04, Knowledge Systems Laboratory, Stanford University, http://kslweb.stanford.edu/. Jennings, N., and Wooldridge, M., (2001), Agentoriented software engineering, J. Bradshaw (Ed.), Handbook of Agent Technology, AAAI/MIT Press. Kiryakov, A., Simov,K., and Dimitrov, M., (2001), Ontomap: the upper-ontology portal, in ‘Proc. of Formal Ontology in Information Systems’, Ogunquit, Maine. Li, L., Wu, B., and Yang, Y., (2005), Semantic Mapping with Multi-Agent Systems, In: Proc. of the IEEE International Conference on e-Technology, e-Commerce and e-Service (EEE’05), pp. 54-57, Hong Kong, March 2005. Li, L., Yang, Y., and Wu, B., (2005), Agent-Based Approach towards Ontology Refinement in Virtual Enterprises, In: Proc. of the 3rd International Conference on Active Media Technology, (AMT 2005), pp. 220-225, Japan, May 2005. Maedche, A., Motik, B., Silva, N., and Volz, R., (2002), MAFRA a mapping framework for distributed ontologies, in ‘Proc. of the 13th European Conference on Knowledge Engineering and Knowledge Management EKAW-2002’, Madrid, Spain. Mena, E., Illarramendi, A., Kashyap, V., and Sheth, A., (2000), OBSERVER: An approach for query processing in global information systems based on interoperation across pre-existing ontologies, Distributed and Parallel Databases, 8(2), pp. 223-271.

Acknowledgements Work reported in this paper is partly supported by Swinburne Vice Chancellor’s Strategic Research Initiative Grant 2002-2004 for project “Internet-based e-business ventures”. The authors are grateful for Shane Grund’s prototyping work.

Mitra, P., Wiederhold, G., and Kersten, M., (2000), A graph-oriented model for articulation of ontology interdependencies, in ‘Proc. of Conference on Extending Database Technology (EDBT 2000)’, Konstanz, Germany.

References Bergamaschi, S., Castano, S., and Vincini, M., (1999), Semantic integration of semistructured and structured data sources, SIGMOD Record Special Issue on Semantic Interoperability in Global Information, 28(1).

Mitra, P., and Wiederhold, G., (2001), An algebra for semantic interoperability of information sources, in ‘IEEE International Conference on Bioinformatics and Biomedical Engineering’, pp. 174182.

Bergamaschi, S., Castano, S., Vincini, M., and Domenico, B., (2001), Semantic integration of heterogeneous information sources, Special Issue

10

Nodine, M., Fowler, J., Ksiezyk, T., Perry, B., Taylor, M., and Unruh, A., (2000), Active information gathering in infosleuth. International Journal of Cooperative Information Systems, 9(1-2), pp. 328. Noy, N. F., and Musen, M. A., (2003), ‘The PROMPT suite: interactive tools for ontology merging and mapping’, International Journal of HumanComputer Studies, 59(6), pp. 983–1024. Silva, N., and Rocha, J., (2003), Ontology mapping for interoperability in semantic web, in ‘Proc. of the IADIS International Conference WWW/Internet 2003 (ICWI2003)’, Algarve, Portugal. Stumme, G., and Maedche, A., (2001), Fca-merge: Bottom-up merging of ontologies, in ‘Proc. of the 7th Intl. Conf. on Artificial Intelligence (IJCAI01)’, pp. 225-230, Seattle, WA, USA. Finin, T., Fritzson, R., McKay, D., McEntire, R., (1994), “KQML as an agent communication language”, in ‘Proc. of the 3rd International Conference on Information and Knowledge Management’, ACM Press. Wooldridge, M., (2002), An introduction to multiAgent systems, John Wiley & Sons, ISBN 047149691X.

11