John H. Gennari

The GuideLine Interchange Format: A Model for Representing Guidelines

OBJECTIVEnTo allow exchange of clinical practice guidelines among institutions and computer-based applications.nnnDESIGNnThe GuideLine Interchange Format (GLIF) specification consists of GLIF model and the GLIF syntax. The GLIF model is an object-oriented representation that consists of a set of classes for guideline entities, attributes for those classes, and data types for the attribute values. The GLIF syntax specifies the format of the test file that contains the encoding.nnnMETHODSnResearchers from the InterMed Collaboratory at Columbia University, Harvard University (Brigham and Womens Hospital and Massachusetts General Hospital), and Stanford University analyzed four existing guideline systems to derive a set of requirements for guideline representation. The GLIF specification is a consensus representation developed through a brainstorming process. Four clinical guidelines were encoded in GLIF to assess its expressivity and to study the variability that occurs when two people from different sites encode the same guideline.nnnRESULTSnThe encoders reported that GLIF was adequately expressive. A comparison of the encodings revealed substantial variability.nnnCONCLUSIONnGLIF was sufficient to model the guidelines for the four conditions that were examined. GLIF needs improvement in standard representation of medical concepts, criterion logic, temporal information, and uncertainty.

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.

Mapping domains to methods in support of reuse

Abstract In this paper, we characterize the relationship between abstract problem-solving methods and the domain-oriented knowledge bases that they use. We argue that, to reuse methods and knowledge bases, we must isolate, as much as possible, method knowledge from domain knowledge. To connect methods and domains, we define declarative mapping relations, and enumerate the classes of mappings. We illustrate our approach to reuse with the PROTEGE-II architecture and a pair of configuration tasks. Our goal is to show that the use of mapping relations leads to reuse with high payoff of saved effort.

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.

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.

Reuse with PROTÉGÉ-II: from elevators to ribosomes

This paper describes the PROTEGE-II environment which supports the construction of knowledge-base systems from reusable components. To assist developers with reuse, the terminologies of both problem-solving methods and knowledge bases should be described as formal ontologies. To connect pre-existing methods to new domains and knowledge bases, we dejine declarative mapping relations, which we use to translate information from domains to methods. It is critical that these mappings are simple, and we develop an ontology and a tool to constrain their construction. With PROTEGE-II and a set of mapping relations, we are able to reuse the same problem-solving method with two disparate tasks: (1) configuring the parts of an elevator system and (2) identzfling plausible con.gurations of helices in a ribosome molecular strand. 1. Reuse for Knowledge-Based Systems Software reuse is an appealing solution to the high cost of software construction and maintenance: If a library of reusable software components were available, then developers could use this library to greatly reduce software development time and effort. Since the goal of software reuse is to reduce development cost, it is valuable to view reuse from an economic perspective. Thus, the effort needed to build a software component library is the reuse investment cost, and the return on that investment is measured by the savings in effort achieved by exploiting reuse over the lifetime of each component. The benefit from a single instance of reuse is the difference between development costs with reuse and estimated development costs without reuse, Reuse is successful only when these benefits outweigh the investment costs. Barnes and Bollinger (1991) outline three ways to make reuse more cost-effective: (1) reduce the initial investment cost of constructing the component; (2) increase the number of times a component is reused; and (3) reduce the cost of sclmting, adapting and reusing a component. In this paper, we focus on the third approach, and especially on the cost of adapting a pre-existing component. We present PROTEGE-II, a development environment and methodology for the construction of knowledge-based sysPermission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of the publication and its date appear, and notice is given that copying is by permission of the Association of Computing Machinery.To copy otherwise, or to republish, requires a fee and/or specific permission. SSR ’95, Seattle. WA. USA terns with reusable components. This environment has been developed within the knowledge-acquisition research community. Thus, it is designed to help developers build systems that include both a knowledge base of domain information, and a problem-solving method that operates on that knowledge base. For our purposes, these two types of components are the objects for reuse. In particular, we demonstrate the reuse of a problem-solving method across two domains: configuring the parts of an elevator system and finding plausible models for the positions of helices within a ribosome strand. The elevator-configuration task is a well-studied problem in the knowledge-acquisition research community, originally described and solved by Marcus, Stout, and McDermott (1988). 1 The task is a constraint-satisfaction problem: given a set of building specifications and requirements such as elevator speed and capacity, and given a large body of knowledge about available elevator components and safety constraints, find a configuration of elevator components so that no constraints are violated. This task was chosen for the Sisyphus-2 project: a benchmark for comparing knowledge modeling efforts in the knowledge-acquisition research community (see Schreiber and Birmingham, in press). The PROTEGE-II solution to this problem has been described in detail by Rothenfluh, Gennari, Eriksson, and Musen (1994), The ribosome topology task is another type of constraint-satisfaction problem, but in a very different domain. Given information about the secondary structure of components of the ribosome structure, such as helices and coils of RNA, and distance-constraint information among those components, the task is to locate the position and orientation of those components, relative to a set of known proteins, such that no distance constraints are violated. This problem has been described by Altman, Weiser, and Noller (1994). These two constraint-satisfaction problems are clearly very different in terminology, and notably different in the size of their search space. Thus, this pair of problems should be a good testbed for software reuse: if a solution can be constructed to solve one problem, it should be adaptable to solve the other. As we will show, PROTEGE-II allows developers to minimize adaptation costs when reusing a problemsolving method. 1. This problem was originally known as the VT task, for vertical transportation.

Reuse, CORBA, and knowledge-based systems

By applying recent advances in the standards for distributed computing, we have developed an architecture for a CORBA implementation of a library of platform-independent, sharable problem-solving methods and knowledge bases. The aim of this library is to allow developers to reuse these components across different tasks and domains. Reuse should be cost-effective; therefore, the library will include standard problem-solving methods whose semantics are well understood and are described with a language for stating the requirements and capabilities of a component. In addition, when a developer needs toadapta component to a new task, the adaptation costs should be minimal. Thus, we advocate the use of separate mediating components that isolate these adaptations from the original component. We demonstrate our approach with an example: an implementation of a problem-solving method, a knowledge-base server, and mediating components that adapt the method to different knowledge bases and tasks.