OKBC: A Programmatic Foundation for Knowledge Base Interoperability (original) (raw)

The Knowledge Model of Prot�g�-2000: Combining Interoperability and Flexibility

Ekaw, 2000

Knowledge-based systems have become ubiquitous in recent years. The World-Wide Web consortium is developing the Resource Description Framework (RDF)-a system for annotating even Web pages with knowledge elements. Knowledge-base developers need to be able to share and reuse knowledge bases that they build. Therefore, interoperability among different knowledge-representation systems is essential. The Open Knowledge-Base Connectivity protocol (OKBC) is a common query and construction interface for frame-based systems that facilitates this interoperability. Protégé-2000 is an OKBC-compatible knowledge-base-editing environment developed in our laboratory. Protégé-2000 has an easy-to-use and configurable interface. We describe its OKBCcompatible knowledge model that makes the import and export of knowledge bases from and to other knowledge-base servers easy. We discuss how the requirements of being usable and configurable knowledge-acquisition tool affected our decisions in the knowledge-model design. Protégé-2000 also has a flexible metaclass architecture which provides configurable templates for new classes in the knowledge base. The use of metaclasses makes Protégé-2000 easily extensible and enables its use with other knowledge models. For example, we demonstrate that we can resolve many of the differences between the knowledge models of Protégé-2000 and RDF by defining a new metaclass set. Resolving the differences between the knowledge models in declarative way enables easy adaptation of Protégé-2000 as an editor for other knowledgerepresentation systems.

The Knowledge Model of Protégé-2000: Combining Interoperability and Flexibility

Knowledge Acquisition, Modeling and Management, 2000

Knowledge-based systems have become ubiquitous in recent years. The World-Wide Web consortium is developing the Resource Description Framework (RDF)—a system for annotating even Web pages with knowledge elements. Knowledge-base developers need to be able to share and reuse knowledge bases that they build. Therefore, interoperability among different knowledge-representation systems is essential. The Open Knowledge-Base Connectivity protocol (OKBC) is a common

Open Knowledge Base Connectivity 2.0.31 — Proposed

Brokers (Contract Number N66001-96-C-8622-P00004) and Large-Scale Repositories of Highly Expressive Reusable Knowledge (Contract Number N66001-97-C-8554). At SRI International, it was supported by a Rome Laboratory contract titled Reusable Tools for Knowledge Base and Ontology Development (Contract Number F30602-96-C-0332), a DARPA contract entitled Ontology Construction Toolkit, and NIH Grant R29-LM-05413-01A1. 2 CHAPTER 1. INTRODUCTION put−slot−values put−slot−values put−slot−values put−slot−values put−slot−values method dispatch Generic function Back−end method Ontolingua Ocelot Classic Loom Figure 1.1: The architecture of the Common Lisp implementation of OKBC. 1.2 Overview of the Protocol OKBC specifies a knowledge model of KRSs (with KBs, classes, individuals, slots, and facets). It also specifies a set of operations based on this model (e.g., find a frame matching a name, enumerate the slots of a frame, delete a frame). An application uses these operations to access and modify knowledge stored in a OKBC-compliant KRS. The current implementations of OKBC is object-oriented: methods in the appropriate object-oriented programming language for an application are used to implement OKBC operations. We refer to the set of methods that implement the protocol for a particular KRS as a back end. Many OKBC operations have default implementations written in terms of other OKBC operations; therefore, the programmer need define only a core subset of all OKBC operations in order to implement a compliant back end. These OKBC operations are called mandatory, and they comprise the OKBC kernel. The default implementations can be overridden within a given back end to improve efficiency. 1.3 Design Objectives The design objectives for OKBC are as follows. Simplicity: It is important to have a relatively simple specification that can be implemented quickly, even if that means sacrificing theoretical considerations or support for idiosyncrasies of a particular KRS. Generality: The protocol should apply to many KRSs, and support all the most common KRS features. For example, it should support all the knowledge access and modification functionality that will be required by a graphical KB editor. No legislation: The protocol should not require numerous changes to an KRS for which the protocol is implemented. That is, the protocol should not legislate the behavior of an underlying KRS, but should serve as an interface between an existing KRS and an application. Performance: Inserting the protocol between an application and a KRS should not introduce a significant performance cost. Consistency: The protocol should exhibit consistent behavior across different KRSs. That is, a given sequence of operations within the protocol should yield semantically equivalent results over a range of KRSs. 1.4. ON TERMINOLOGY 3 Precision: The specification of the protocol should be as precise and unambiguous as possible. Extensibility: The protocol must support the variability in capabilities of KRSs, and the need to add new KRS features over time without penalizing users of less powerful systems. Keywords All keywords that appear in the OKBC specification are defined as the values of global variables prefixed by 'key '. For example, the :all keyword is the value of key all. Because C does not allow for dynamically allocated structures to be included in compiled code or header files, the function okbc init must be called prior to referencing any keywords at runtime. Data Structures Every OKBC object is implemented as a Okbc Node struct. Return Values Each OKBC operation returns a struct okbc node * if it is single valued, a struct values * is returned if it is multi-valued, or void * if it returns no values. C does not support multiple return values from functions. Operations returning multiple values return a pointer to a values struct. Functions on values include nth value, first value, and length. Exceptions Every OKBC operation clears an error flag before executing, and sets it if an error occurs. It is the responsibility of the application to detect and handle errors. For the specific error flags, consult the header file for the C implementation. Language Specific Declarations and prototypes are defined in the file okbc.h. The function okbc init must be called prior to executing any OKBC operation or referencing any keyword at runtime. 3.6.3 Java Binding Naming Each OKBC operation that takes a KB argument is defined as a method of the class OkbcKb. Dashes are replaced by underscores, and the name is all in lower case. For example, get-slot-values would be called kb.get slot values(...), where kb is an instance of the class OkbcKb. Arguments Java allows for arguments to be defaulted from right to left. The Java binding provides default values for the rightmost arguments that have simple defaults. Check the method definitions in the OkbcKb class to verify argument defaulting. Data structures The Node class is the root class for all OKBC objects. Subclasses of Node include Symbol, Kb, etc. All methods implementing OKBC operations return either a Node or a Values object or are void methods. Return Values Each OKBC operation returns a Node object if it is single valued, a Values object if it is multi-valued, or void if it returns no values. Java does not support multiple return values from methods. Operations returning multiple values return a Values object, which supports the methods nthValue, firstValue, and length. Keywords All keywords that appear in the OKBC specification are defined as public static final members on the Node class. The name of each keyword is prefixed by 'key '. For example, the :all keyword is the value of Node.key all.

The logic of knowledge bases: A review

2002

A knowledge-based system (KBS) contains (by definition) an explicitly codified body of knowledge, which causally determines its behavior. Hence, at a coarse-grained level of abstraction, KB-Ss can be characterized in terms of two components:(1) a knowledge base, encoding the knowledge embodied by the system, and (2) a reasoning engine, which is able to query the knowledge base, infer or acquire knowledge from external sources, and add new knowledge to the knowledge base.

Using frames for knowledge representation in a CORBA-based distributed environment

Knowledge-Based Systems, 2008

Frame knowledge model provides a natural way of clustering knowledge and particularly dynamic rules around frames which in turn provides the natural way of distributing knowledge among networks hosts. Frame knowledge representation is very similar to traditional object-oriented approach. In the present paper the general features of the frames are considered. The basic principles and the architecture of the software tool for constructing knowledge-based systems are discussed. The application of planning techniques to maintain the frame hierarchy model is specified and further developed by defining a generalized algorithm of the Planner and Executor.

A Frame-Based Approach for Integrating Heterogeneous Knowledge Sources

2016

Large knowledge bases are increasingly available in the web, linked to each other so that their information can be combined and joined and they can be queried as a single knowledge base or navigated by software agents. The resulting global knowledge base is usually referred to as linked data, linked open data, linked open data cloud, or the semantic web. Commonly used standards for these knowledge bases specify a simple and homogeneous syntax based on triples that can be interpreted, under some simplifications, as defining a labelled directed graph, where the nodes and the edges are identified with internationalized resource identifiers that use domains owned by the stakeholder that publishes each graph. This makes easier the aggregation of data, which can be reduced to a union of triples. However, the use of different modelling patterns in different graphs requires any structured query over the global graph to combine all possible modelling patterns that may exist in it, including ...

Large-Scale Repositories of Highly Expressive Reusable Knowledge

We describe an ongoing project to develop technology that will support collaborative construction and effective use of distributed large-scale repositories of highly expressive reusable ontologies. We are focusing on developing a distributed server architecture for ontology construction and use, representation formalisms that remove key barriers to expressing essential knowledge in and about ontologies, ontology construction tools, and tools for obtaining domain models for use in applications from large-scale ontology repositories. We are building on the results of the DARPA Knowledge Sharing Effort, specifically by using the Knowledge Interchange Format (KIF) as a core representation language and the Ontolingua system as a core ontology development environment.

Formalizing Knowledge by Ontologies: OWL and KIF

During the last years, the activities of knowledge formalization and sharing useful to allow for semantically enabled management of information have been attracting growing attention, expecially in distributed environments like the Web. In this report, after a general introduction about the basis of knowledge abstraction and its formalization through ontologies, we briefly present a list of relevant formal languages used to represent knowledge: CycL, F-Logic, LOOM, KIF, Ontolingua, RDF(S) and OWL. Then we focus our attention on the Web Ontology Language (OWL) and the Knowledge Interchange Format (KIF). OWL is the main language used to describe and share ontologies over the Web: there are three OWL sublanguages with a growing degree of expressiveness. We describe its structure as well as the way it is used in order to reasons over asserted knowledge. Moreover we briefly present three relevant OWL ontology editors: Protégé, SWOOP and Ontotrack and two important OWL reasoners: Pellet and FACT++. KIF is mainly a standard to describe knowledge among different computer systems so as to facilitate its exchange. We describe the main elements of KIF syntax; we also consider Sigma, an environment for creating, testing, modifying, and performing inference with KIF ontologies. We comment some meaningful example of both OWL and KIF ontologies and, in conclusion, we compare their main expresive features.

An Architecture of Distributed Frame Hierarchy for Knowledge Sharing and Reuse in Computer Networks

2002

An architecture for building distributed intelligent systems is considered, based on production-frame knowledge representation with distributed frame hierarchy, in which knowledge fragments located on different network nodes can be used cooperatively in the process of distributed or local inference. Frame knowledge representation can also serve as a common denominator when integrating knowledgebase with imperative components or relational data, because objects and component interfaces as well as relational tables can be transparently represented by frames or frame classes.