Stephen Cranefield

UML for ontology development

Ontologies are becoming increasingly important because they provide the critical semantic foundation for many rapidly expanding technologies such as software agents, e-commerce and knowledge management (McGuinness, 2002). The Unified Modelling Language (UML)1 has been widely adopted by the software engineering community and its scope is broadening to include more diverse modelling tasks. This paper discusses the recent convergence of UML and ontologies and suggests some possible future directions.

A Study on Feature Analysis for Musical Instrument Classification

In tackling data mining and pattern recognition tasks, finding a compact but effective set of features has often been found to be a crucial step in the overall problem-solving process. In this paper, we present an empirical study on feature analysis for recognition of classical instrument, using machine learning techniques to select and evaluate features extracted from a number of different feature schemes. It is revealed that there is significant redundancy between and within feature schemes commonly used in practice. Our results suggest that further feature analysis research is necessary in order to optimize feature selection and achieve better results for the instrument recognition problem.

Norm creation, spreading and emergence: A survey of simulation models of norms in multi-agent systems

Norms in human societies are expectations of behaviours of the individuals. In human societies, there are several types of norms such as moral norms, social norms and legal norms (laws). In multi-agent systems, software agents are modelled as possessing characteristics and behaviour borrowed from human societies. In order to design and develop robust artificial agent societies, it is important to understand different approaches proposed by researchers by which norms can spread and emerge within agent societies. This paper makes three contributions to the study of norms. Firstly, based on the simulation research on norms, we propose a life-cycle model for norms. Secondly, we discuss different mechanisms used by researchers to study norm creation, identification, spreading, enforcement and emergence. We also discuss the strengths and weaknesses of each of these mechanisms. Thirdly, in the context of identifying the desired characteristics of the simulation models of norms we discuss the research issues that need to be addressed.

Role model based mechanism for norm emergence in artificial agent societies

In this paper we propose a mechanism for norm emergence based on role models. The mechanism uses the concept of normative advice whereby the role models provide advice to the follower agents. Our mechanism is built using two layers of networks, the social link layer and the leadership layer. The social link network represents how agents are connected to each other. The leadership network represents the network that is formed based on the role played by each agent on the social link network. The two kinds of roles are leaders and followers. We present our findings on how norms emerge on the leadership network when the topology of the social link network changes. The three kinds of social link networks that we have experimented with are fully connected networks, random networks and scale-free networks.

Executing Agent UML Diagrams

Interaction protocols (IPs) are necessary for specifying and controlling the conversation of software agents in open multi-agent systems. This research investigated the automatic interpretation of IPs defined using the Agent Unified Modeling Language (AUML). Our Plug-in for Agent UML Linking (PAUL) is based on the FIPA-compliant agent platform Opal and the Eclipse Modeling Framework (EMF). PAUL enables developers to implement agent conversations quickly and easily by attaching application-specific code to an AUML model of an interaction protocol and executing this interaction protocol.

Ontologies for Interaction Protocols

In this paper we propose reducing the degree of human interpretation currently necessary to understand an interaction protocol by describing at an abstract level the required agent actions that must be ‘plugged into’ the protocol for it to be executed. In particular, this can be done by designing and publishing ontologies describing the input and output data that are processed during the protocol’s execution together with the actions and decisions that the agents must perform. An agent (or agent developer) that has previously defined mappings between the internal agent code and the actions and decisions in an ontology would then be able to interpret any interaction protocol that is defined with reference to that ontology. The discussion is based on the use of Coloured Petri Nets to represent interaction protocols and the Unified Modeling Language (UML) for ontology modelling. An alternative approach using Agent UML (AUML) is also outlined.

A MULTI-AGENT SYSTEM FOR THE INTEGRATION OF DISTRIBUTED ENVIRONMENTAL INFORMATION

Abstract This paper describes a multi-agent platform to be used for the integration of environmental information that may be distributed over a network. The system is designed to work as a collection of collaborating agents. Information sources are encapsulated as data source agents (DSAs) that accept messages in an agent communication language. Here we describe how queries can be entered into the system and information collected from multiple sources. A key component of the query module is the planner agent, which takes a query and transforms it first to a calculus, then to an algebraic expression in order to break it into subqueries which an executor agent can send to the DSAs. As part of this process, the query is translated from user-level ontologies to lower level ontologies relevant to the DSAs. Query results need not be returned within an ACL message, but may instead be represented by a Common Object Request Broker Architecture (CORBA) object reference which may be used to obtain the result set. The architecture and operation of these agent components is described and an example is presented of how environmental information can be queried.

Verifying social expectations by model checking truncated paths

One approach to moderating the expected behaviour of agents in open societies is the use of explicit languages for defining norms, conditional commitments and/or social expectations, together with infrastructure supporting conformance checking. This paper presents a logical account of the fulfilment and violation of social expectations modelled as conditional rules over a hybrid linear propositional temporal logic. Our semantics captures the intuition that the fulfilment or violation of an expectation must be determined without recourse to information from later states. We define a means of updating expectations from one state to the next based on formula progression, and show how conformance checking was implemented by extending the MCLITE and MCFULL algorithms of the Hybrid Logics Model Checker.

Norm emergence in agent societies formed by dynamically changing networks

In this paper we describe how our previously proposed role model agent mechanism for norm emergence can be applied to artificial agent societies with network topologies that are changing dynamically. Dynamically changing network topologies account for agents joining and leaving the network and the links that are created and removed between agents in a society. In order to construct a dynamically changing network we have adopted a model representing agents as particles colliding in a social space. We demonstrate that the role model agent mechanism for norm emergence works on top of dynamically created network topologies that represent social relationship structures.

Agent-based integration of Web Services with Workflow Management Systems

Rapid changes in the business environment call for more flexible and adaptive workflow systems. Researchers have proposed that Workflow Management Systems (WfMSs) comprising multiple agents can provide these capabilities. We have developed a multiagent based workflow system, JBees, which supports distributed process models and the adaptability of executing processes. Modern workflow systems should also have the flexibility to integrate available Web Services as they are updated. In this paper we discuss how our agent-based architecture can be used to bind and access Web Services in the context of executing a workflow process model.