Dung N. Lam

Comprehending agent software

Software comprehension (understanding software structure and behavior) is essential for developing, maintaining, and improving software. This is particularly true of agent-based systems, in which the actions of autonomous agents are affected by numerous factors, such as events in a dynamic environment, local uncertain beliefs, and intentions of other agents. Existing comprehension tools are not suited to such large, concurrent software and do not leverage concepts of the agent-oriented paradigm to aid the user in understanding the softwares behavior. To address the software comprehension of agent-based systems, this research proposes a method and accompanying tool that automates some of the manual tasks performed by the human user during software comprehension, such as explanation generation and knowledge verification.

Using Consensus Clustering for Multi-view Anomaly Detection

This paper presents work on automatically characterizing typical user activities across multiple sources (or views) of data, as well as finding anomalous users who engage in unusual combinations of activities across different views of data. This approach can be used to detect malicious insiders who may abuse their privileged access to systems in order to accomplish goals that are detrimental to the organizations that grant those privileges. To avoid detection, these malicious insiders want to appear as normal as possible with respect to the activities of other users with similar privileges and tasks. Therefore, given a single type or view of audit data, the activities of the malicious insider may appear normal. An anomaly may only be apparent when analyzing multiple sources of data. We propose and test domain-independent methods that combine consensus clustering and anomaly detection techniques. We benchmark the efficacy of these methods on simulated insider threat data. Experimental results show that combining anomaly detection and consensus clustering produces more accurate results than sequentially performing the two tasks independently.

Tools for analyzing intelligent agent systems

When developing sophisticated multi-agent systems whose behaviors include collaboration, negotiation, and conflict resolution, analyzing and (empirically) verifying agent system behavior is a challenging task. To aid the developer in such tasks, this paper presents an approach that combines two software engineering tools - the Tracer Tool and the TTL Checker, which together record agent activities as execution traces and verify that the traces satisfy specified properties. The objective of the combined tool is to aid the user in redesigning, debugging, and maintaining the agent system. The Tracer Tool ensures that the users comprehension of the system behavior is accurate with respect to the execution traces and provides explanations of anomalous behavior, which can be detected as a failed behavioral property by the TTL Checker. The integrated approach has been applied to an agent-based system designed to coordinate unmanned aerial vehicles.

Sensible agents: an implemented multi-agent system and testbed

Sensible Agents have been engineered to solve distributed problems in complex, uncertain, and dynamic domains. Each Sensible Agent is composed of four modules: the Action Planner, Perspective Modeler, Conflict Resolution Advisor, and Autonomy Reasoner. These modules give Sensible Agents the abilities to plan, model, resolve individual conflicts, and change agent system organization. Two component suites provide a variety of user- oriented features: the Sensible Agent Run- time Environment (SARTE) and the Sensible Agent Testbed. The SARTE provides facilities for instantiating Sensible Agents, deploying a Sensible Agent system, and monitoring run- time operations. The Sensible Agents Testbed facilitates automated generation of parameter combinations for controlled experiments, deterministic and non-deterministic simulation, and configuration of Sensible Agents and data acquisition. Experimentation is a crucial step in gaining insight into the behavior of agents, as well as evidence toward or against hypotheses. Using a real- world example, this paper explains and demonstrates: (1) the functional capabilities of Sensible Agents, (2) the Sensible Agent Run- Time Environments facilities for monitoring and control of Sensible Agent systems and (3) the experimental set- up, monitoring, and analysis capabilities of the Sensible Agent Testbed.

Infrastructure for Design, Deployment and Experimentation of Distributed Agent-based Systems: The Requirements, The Technologies, and An Example

This paper discusses infrastructure for design, development, and experimentation of multi-agent systems. Multi-agent system design requires determining (1) how domain requirements drive the use of agents and AI techniques, (2) what competencies agents need in a MAS, and (3) which techniques implement those competencies. Deployment requirements include code reuse, parallel development through formal standardized object specifications, multi-language and multi-platform support, simulation and experimentation facilities, and user interfaces to view internal module, agent, and system operations. We discuss how standard infrastructure technologies such as OMG IDL, OMG CORBA, Java, and VRML support these services. Empirical evaluation of complex software systems requires iteration through combinations of experimental parameters and recording desired data. Infrastructure software can ease the setup, running, and analysis of large-scale computational experiments. The development of the Sensible Agent Testbed and architecture over the past six years provides a concrete example. The design rationale for the Sensible Agent architecture emphasizes domain-independent requirements and rapid deployment to new application domains. The Sensible Agent Testbed is a suite of tools providing or assisting in setting up, running, visually monitoring, and chronicling empirical testing and operation of complex, distributed multi-agent systems. A thorough look at the various Sensible Agents infrastructure pieces illustrates the engineering principles essential for multi-agent infrastructure, while documenting the software for users.

Automated analysis and verification of agent behavior

Comprehending and analyzing agent behavior is an arduous task due to complexities in agent systems and sophistication of agent behaviors, in addition to the common difficulties with any complex software system. This paper presents an integrated approach for the analysis and verification of behaviors of agent-based systems. The approach is a result of collaboration between the Tracer Tool and the TTL Checker, which together automate the analysis and verification of agents in an implemented agent system with the aim of aiding the user in redesigning, debugging, and maintaining the software system. The Tracer Tool ensures that the users comprehension of the system behavior is accurate and provides explanations of anomalous behavior, which can be detected as a failed behavioral property by the TTL Checker. The integrated approach has been applied successfully in a case study in the domain of Unmanned Aerial Vehicles.

Sensible Agent Testbed Infrastructure for Experimentation

The design and analysis of multi-agent systems is difficult due to complex agent capabilities and rich interactions among agents. Experimentation is a crucial step in gaining insight into the behavior of agents. Experiments must be flexible, easily configurable, extensible, and repeatable. This paper presents the Sensible Agent Testbed, which supports these requirements. The CORBA infrastructure of the Testbed platform and the formally-defined interfaces among Testbed components are described. The Testbed promotes many levels of modularity, facilitating parallel development of agents and agent capabilities. This approach provides many opportunities for different types of experiments. Experimental setup through a configuration file is simplified using the Init File Maker, which has the capability to automate the production of multiple configurations. Overall, the Sensible Agent Testbed provides a solid infrastructure supporting multi-agent experiments.

Automated interpretation of agent behaviour

Software comprehension, which is essential for debugging and maintaining software systems, has lacked attention in the agent community. Comprehension has been a manual process, involving the analysis and interpretation of log files that record agent behaviour in the implemented system. This paper describes an approach and tool to automate creating interpretations of agent behaviour from observations of the implementation execution, thus helping users (i.e. designers, developers, and end-users) to understand the motivations of agent actions. By explicitly modelling the user’s comprehension of the implemented system as background knowledge for the tool, feedback can be provided as to whether the user’s comprehension accurately represents the implementation’s behaviour and, if not, how it can be corrected. Additionally, with the aid of the Tracer Tool, many of the manual tasks are automated, such as verifying that agents are behaving as expected, identifying unexpected behaviour and generating explanations for any particular observation.

Verifying and Explaining Agent Behavior in an Implemented Agent System

As agent systems become more sophisticated, there is a growing need for agent-oriented debugging, maintenance, and testing methods and tools. This paper presents the Tracing Method and accompanying Tracer tool to help verify actual agent behavior in the implemented system against expected (or designed) agent behavior. The Tracing Method captures dynamic run-time data as actual agent behavior, creates modeled interpretations in terms of agent concepts (e.g. beliefs, goals, and intentions), and compares those models to the agent behavior expected by the designer or developer; thereby, gaining insight into both the design and the implemented agent behavior. The Tracer tool can help: (1) determine if agent design specifications are correctly implemented and guide debugging efforts and (2) discover and examine motivations for agent behaviors such as beliefs, communications, and intentions.

Graph-based data warehousing using the core-facets model

There are a growing number of data-mining techniques that model and analyze data in the form of graphs. Graphs can link otherwise disparate data to form a holistic view of the dataset. Unfortunately, it can be challenging to manage the resulting large graph and use it during data analysis. To facilitate managing and operating on graphs, the Core-Facets model offers a framework for graph-based data warehousing. The Core-Facets model builds a heterogeneous attributed core graph from multiple data sources and creates facet graphs for desired analyses. Facet graphs can transform the heterogeneous core graph into various purpose-specific homogeneous graphs, thereby enabling the use of traditional graph analysis techniques. The Core-Facets model also supports new opportunities for multi-view data mining. This paper discusses an implementation of the Core-Facets model, which provides a data warehousing framework for tasks ranging from data collection to graph modeling to graph preparation for analysis.