Henrik Eriksson

Task modeling with reusable problem-solving methods

Problem-solving methods for knowledge-based systems establish the behavior of such systems by defining the roles in which domain knowledge is used and the ordering of inferences. Developers can compose problem-solving methods that accomplish complex application tasks from primitive, reusable methods. The key steps in this development approach are task analysis, method selection (from a library), and method configuration. Protege-ii is a knowledge-engineering environment that allows developers to select and configure problem-solving methods. In addition, Protege-ii generates domain-specific knowledge-acquisition tools that domain specialists can use to create knowledge bases on which the methods may operate. n nThe board-game method is a problem-solving method that defines control knowledge for a class of tasks that developers can model in a highly specific way. The method adopts a conceptual model of problem solving in which the solution space is construed as a “game board” on which the problem solver moves “playing pieces” according to prespecified rules. This familiar conceptual model simplifies the developers cognitive demands when configuring the board-game method to support new application tasks. We compare configuration of the board-game method to that of a chronological-backtracking problem-solving method for the same application tasks (for example, towers of Hanoi and the Sisyphus room-assignment problem). We also examine how method designers can specialize problem-solving methods by making ontological commitments to certain classes of tasks. We exemplify this technique by specializing the chronological-backtracking method to the board-game method.

Ontology-based configuration of problem-solving methods and generation of knowledge-acquisition tools: application of PROTÉGÉ-II to protocol-based decision support

PROTEGE-II is a suite of tools and a methodology for building knowledge-based systems and domain-specific knowledge-acquisition tools. In this paper, we show how PROTEGE-II can be applied to the task of providing protocol-based decision support in the domain of treating HIV-infected patients. To apply PROTEGE-II, (1) we construct a decomposable problem-solving method called episodic skeletal-plan refinement, (2) we build an application ontology that consists of the terms and relations in the domain, and of method-specific distinctions not already captured in the domain terms, and (3) we specify mapping relations that link terms from the application ontology to the domain-independent terms used in the problem-solving method. From the application ontology, we automatically generate a domain-specific knowledge-acquisition tool that is custom-tailored for the application. The knowledge-acquisition tool is used for the creation and maintenance of domain knowledge used by the problem-solving method. The general goal of the PROTEGE-II approach is to produce systems and components that are reusable and easily maintained. This is the rationale for constructing ontologies and problem-solving methods that can be composed from a set of smaller-grained methods and mechanisms. This is also why we tightly couple the knowledge-acquisition tools to the application ontology that specifies the domain terms used in the problem-solving systems. Although our evaluation is still preliminary, for the application task of providing protocol-based decision support, we show that these goals of reusability and easy maintenance can be achieved. We discuss design decisions and the tradeoffs that have to be made in the development of the system.

Reusable ontologies, knowledge-acquisition tools, and performance systems: PROTE´GE´-II solutions to Sisyphus-2

Abstract This paper describes how we applied the PROTEGE-II architecture to build a knowledge-based system that configures elevators. The elevator-configuration task was solved originally with a system that employed the propose-and-revise problem-solving method (VT). A variant of this task, here named the Sisyphus-2 problem, is used by the knowledge-acquisition community for comparative studies. PROTEGE-II is a knowledge-engineering environment that focuses on the use of reusable ontologies and problem-solving methods to generate task-specific knowledge-acquisition tools and executable problem solvers. The main goal of this paper is to describe in detail how we used PROTEGE-II to model the elevator-configuration task. This description provides a starting point for comparison with other frameworks that use abstract problem-solving methods. Beginning with the textual description of the elevator-configuration task, we analysed the domain knowledge with respect to PROTEGE-II’s main goal: to build domain-specific knowledge-acquisition tools. We used PROTEGE-II’s suite of tools to construct a knowledge-based system, called ELVIS, that includes a reusable domain ontology, a knowledge-acquisition tool, and a propose-and-revise problem-solving method that is optimized to solve the elevator-configuration task. We entered domain-specific knowledge about elevator configuration into the knowledge base with the help of a task-specific knowledge-acquisition tool that PROTEGE-II generated from the ontologies. After we constructed mapping relations to connect the knowledge base with the method’s code, the final executable problem solver solved the test case provided with the Sisyphus-2 material. We have found that the development of ELVIS has afforded a valuable test case for evaluating PROTEGE-II’s suite of system-building tools. Only projects based on reasonably large problems, such as the Sisyphus-2 task, will allow us to improve the design of PROTEGE-II and its ability to produce reusable components.

Generation of knowledge-acquisition tools from domain ontologies

Abstract Metalevel tools can support the software development process by automating the design of task- and application-specific tools. DASH is a metalevel tool that allows developers to generate domain-specific knowledge-acquisition tools from domain ontologies. Domain specialists use the knowledge-acquisition tools generated by DASH to instantiate the concepts and relationships defined in the domain ontologies. The output of the knowledge-acquisition tools is a collection of instances that constitute the knowledge base for a knowledge-based system. To automate the generation of appropriate tools, the DASH architecture uses a dialog-design module to produce a dialog structure that defines the target tool at the editor and window level. Given the dialog structure, a layout-design module completes the window layouts. DASH allows the developer to custom tailor the layout of the knowledge-acquisition tool for its users, and to store such modifications persistently so that they can be reapplied when the target tool is regenerated. The DASH implementation is based on a mapping problem-solving method that defines the tool-design steps. The DASH Development Environment (DDE) is an application-specific environment that supports the configuration of the mapping method and the maintenance of DASH. We have used DASH to generate several knowledge-acquisition tools for a broad range of application tasks.

Beyond data models for automated user interface generation

Researchers in the area of automated design of user interfaces have shown that the layout of an interface can, in many cases, be generated from the application’s data model using an intelligent program that applies design rules. The specification of interface behavior, however, has not been automated in the same manner, and is mostly a programmatic task. Mecano is a model-based user-interface development environment that extends the notion of automating interface design from data models. Mecano uses a domain model—a high-level knowledge representation that augments significantly the expressiveness of a data model—to generate automatically both the static layout and the dynamic behavior of an interface. Mecano has been applied successfully to completely generate the layout and the dynamic behavior of relatively large and complex, domain-specific, formand graph-based interfaces for medical applications and several other domains.

Metatools for knowledge acquisition

Four prototype metatools, Protege, Dots, Dash, and Spark, which researchers are using to experiment with the automatic generation of knowledge-acquisition tools, are discussed. Protege and Dots are stand-alone metatools; Dash and Spark are subsystems. Dash is part of Protege II, a design environment for knowledge-based systems. Spark is part of the Spark, Burn, and Firefighter framework for the design of application systems. The two stand-alone tools, their environments, and their subsystems are compared. Protege demonstrates how one can instantiate knowledge-acquisition tools from a description of a problem-solving method. Dots, on the other hand, lets one design knowledge-acquisition tools for many applications. Spark, Burn, and Firefighter are similar to Protege II in that they emphasize developing problem-solving methods from reusable components, although Spark, Burn and Firefighter associate a knowledge-acquisition tool with each method in the library. Protege II uses Dash to generate knowledge-acquisition tools from domain ontologies.<<ETX>>

Conceptual models for automatic generation of knowledge-acquisition tools

Interactive knowledge-acquisition (KA) programs allow users to enter relevant domain knowledge according to a model predefined by the tool developers. KA tools are designed to provide conceptual models of the knowledge to their users. Many different classes of models are possible, resulting in different categories of tools. Whenever it is possible to describe KA tools according to explicit conceptual models, it is also possible to edit the models and to instantiate new KA tools automatically for specialized purposes. Several meta-tools that address this task have been implemented. Meta-tools provide developers of domain-specific KA tools with generic design models, or meta-views, of the emerging KA tools. The same KA tool can be specified according to several alternative meta-views.