- Email: [email protected]
Automated conversion between different knowledge representation formats
Knowledge-Based Systems 19 (2006) 404–412 www.elsevier.com/locate/knosys
Automated conversion between different knowledge representation formats Haining Yao *, Letha Etzkorn Department of Computer Science, University of Alabama in Huntsville, Huntsville, AL 35899, USA Received 13 December 2004; accepted 6 April 2006 Available online 5 June 2006
Abstract One problem in knowledge based systems is the problem of knowledge sharing. Many systems use proprietary frameworks for storing knowledge, and even those systems that use standard knowledge representation formats have the problem that more than one such format exists. Conceptual Graphs and Resource Description Framework are two general-purpose knowledge representation models. Since they are structurally similar in syntax, concepts, and semantics, converting Conceptual Graph models to Resource Description Framework models without loss of semantic meaning is feasible. In this paper, we introduce a semantic converter which converts knowledge representation in Conceptual Graphs into representation in Resource Description Framework, as an experiment to overcome the barriers in knowledge sharing and reuse due to lack of consensus of knowledge representation formats between these two knowledge representation models. 2006 Elsevier B.V. All rights reserved. Keywords: Knowledge representation; Conceptual graphs; Resource description framework
1. Introduction Knowledge systems have been widely used in many different areas including knowledge acquisition, dynamic composition of services, service matching, etc. In knowledge system applications, domain knowledge is encoded by a wide variety of knowledge representation languages for sharing and reuse [10]. The diversity of knowledge representation forms results in knowledge system developers choosing one formalism over others for a specific application. However, knowledge systems expressed in one form usually cannot be directly incorporated or converted into other forms. Sharing and reusing knowledge expressed in different representations becomes more important as the use of knowledge based systems continues to expand. This involves translating knowledge systems from one representation to another. Manually reformatting knowledge repre*
Corresponding author. Tel.: +1 256 824 5124; fax: +1 256 8246239. E-mail addresses: [email protected] (H. Yao), [email protected] (L. Etzkorn). 0950-7051/$ - see front matter 2006 Elsevier B.V. All rights reserved. doi:10.1016/j.knosys.2006.04.005
sented from one representation model to another is obviously a hard and tedious work for a large knowledge system. So knowledge representation translation tools that can help automate the translation process are needed. In this paper, we will discuss translating knowledge representation between two well-known knowledge representation standards: the Conceptual Graph (CG) model and the Resource Description Framework (RDF) model. During our research we found that CGs and RDF are very similar in concepts, syntax, and semantics [1]. CGs and RDF are both graph models depicted by nodes connected with arcs: in CGs, concept nodes are connected by conceptual relationship arcs; in RDF, resource nodes are connected with property arcs. Both CGs and RDF are theory models deriving formal semantics from the abstract syntax represented by the graph models. Both CGs and RDF are designed to represent domain knowledge, or formal systematic semantics for knowledge sharing and reuse [17]. In our earlier research, we provided preliminary examination of the high level theory for converting CGs into RDF. In this work, we have concentrated primarily on
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
the practical implementation of the conversion from CGs into RDF. By employing our converter, a CG model in Conceptual Graph Interchange Form (CGIF) can be automatically converted into a RDF model in RDF/XML without changing the semantics. In this paper, we discuss the practical aspects of the CG to RDF conversion. We describe the converter we developed to perform this conversion, and discuss the success of this approach as well as its limitations. No other researcher, to our knowledge, has converted from CGs to RDF, although Corbey et al. [3] performed a conversion in the other direction, from RDF to CGs. The conversion from CGs to RDF is more difficult than the reverse since CGs have several constructs and concepts that are nonexistent in RDF (see Section 2.5). The purpose of our work is to augment knowledge sharing and reuse between knowledge models expressed in different representations, here, CGs and RDF. The interchangeability between the two models will benefit the following: it will enable webization of existing CG applications, and knowledge sharing and exchanging will be enhanced. Finally, this allows the comparison of different information processing rules and algorithms for CGs and RDF applications [17]. In this paper, we provide background material on CGs and RDF in Section 2. We illustrate the CGs to RDF converter in Section 3. And finally in Section 4, we conclude our current work and provide thoughts for future research in the area of knowledge representation conversion. 2. CGs and RDF 2.1. CG Conceptual Graphs (CGs) are an abstract representation used to logically model domain knowledge by defining concepts and conceptual relationships between concepts. In the model represented by conceptual graphs, concepts are nodes referring to entities, and conceptual relations are arcs linking concepts together and referring to the conceptual relationship between concepts. A conceptual graph model is basically a graph: a conceptual graph is represented as a bipartite graph. To make CGs machine-processable, Conceptual Graph Interchange Form (CGIF) is employed as the representation for encoding knowledge represented by bipartite graphs into machine-readable character strings. Another conceptual graph model representation is Linear Form (LF) which makes CGs more human-readable and saves space. The following is an example illustrating three CG forms to represent the meaning of ‘‘a person named ‘John’’’. (1) Display Form: (2) CGIF: (Name [Employee: ‘ID1234’] [Literal: ‘‘John’’]) (3) LF: [Employee: ‘ID1234’] fi (Name) fi [Literal: ‘‘John’’]
405
2.2. RDF/RDF-S Resource Description Framework (RDF) is a generalpurpose knowledge representation framework developed by W3C for representing information about resources in the web. RDF is also a graph model that is depicted as a directed labeled graph: a statement is represented by a node for the subject, a node for the object, and an arc for the predicate that is directed from the subject node to the object node. In RDF, each statement is a triple corresponding to a single arc (a predicate) with a beginning node (a subject) and an ending node (an object). The principle idea RDF is based on is that things are naturally described by object-attribute-value triples: resources are described using properties which have values. RDF draws upon ideas from knowledge representation, artificial intelligence, and data management, logic-based knowledge representation, frames, and relational databases [5,7]. RDF is a graph model, in order to be machine-processable, RDF employs Extensible Markup Language (XML) as its normative interchange syntax. Besides the RDF/XML, triple notation is also used for human readable RDF statements: subject, predicate, and object are listed in a triple to describe an RDF statement. One characteristic that distinguishes RDF from other information representation languages is that RDF uses Uniform Resource Identifiers (URI) references as resources’ or properties’ identities in RDF statements. Theoretically, any resource can be described in RDF as long as it can be identified by a URI reference. And the URI reference doesn’t have to be retrievable in the World Wide Web: as long as the URI reference is unique to identify a ‘‘thing’’ whether it is a resource or a property. RDF schema (RDF-S) is the RDF vocabulary description language to be used to provide a further description mechanism to define classes or groups of related resources and the relationships between the resources. RDF-S is a semantic extension of RDF, but the external semantics of RDF-S primitives is not contained in RDF itself. For example, rdfs:Class and rdfs:Property are used to define the class of resources that are RDF classes or RDF properties; and rdfs:subClassOf and rdfs:subPropertyOf are used as properties to define relationship between RDF-S classes. RDF-S defines type systems similar to the type systems of object-oriented programming languages; however RDF-S defines properties in terms of classes of resources, while object-oriented programming languages define the classes in terms of the properties that the instances of the classes may have [5,7] Fig. 1. The following is similar to the example we have shown in Section 2.1 illustrating CG representations. Here, the
Employee: ‘ID1234’
Name
Literal: “John”
Fig. 1. A Conceptual Graph represented in display form.
406
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
http://cs.uah.edu/kb/Person http://www.w3.org/199902/22-rdf-syntax-ns#type http://cs.uah.edu/kb/ID1234 http://cs.uah.edu/kb/Name John
Fig. 2. An RDF represented in graph format.
example is shown in three RDF representations this time: in graph mode expressed by Fig. 2, then in XML, and finally in triples. The three representations have equivalent meaning. (1) Graph format: (2) XML format: John (3) Triple format: ‘‘John’’ Compared with Web Ontology Language (OWL), RDF-S is a lightweight schema language. OWL is designed to make information content machine-processable, instead of just representing information as human-readable [2,4]. OWL is based on RDF and RDF-S, but OWL provides additional primitives to facilitate greater machine interpretability [2,4,9,11,12]. 2.3. CGs and RDF comparison Although designed for different purposes, RDF and CG are both graph models and are ‘‘strikingly similar’’ [1]: both CGs and RDF are graph models that include nodes connected by arcs, where nodes represent entities (concepts in CGs, and resources in RDF), and arcs represents relationships (relations in CGs, and properties in RDF) between entities. From the knowledge representation language point of view, CGs and RDF are both designed as simple data models to derive formal semantics from the
abstract syntax represented by the graphs, and to provide a basis for semantic meaning reasoning. Since CGs and RDF are both theory-models with similar syntactic modeling structures, it is possible to convert CGs to RDF while retaining semantics. 2.4. Notio and Jena Notio [13,14] is a Java API for manipulating CGs. Notio provides facilities to structure CGs, string CGs into CG normative form CGIF and vice versa, to parse CGs represented in CGIF strings into CG model in memory for processing, etc. Jena [6,8], developed in the HP lab, is a Java API for handling RDF models, including building, parsing, and inferencing RDF models, etc. We researched the current available software on manipulating CGs and RDF, and found that these two Java APIs, Notio, and Jena, have been used to construct some successful CG applications and RDF applications, respectively. Since our purpose is to develop an automated conversion tool for translating knowledge models represented in CGs into knowledge models represented in RDF, we incorporated Notio, the CGs’ handling API, and Jena, the RDF handling API, into our converter: Notio packages are used to parse CG models in CGIF and build CG models in memory; and Jena packages are used to build RDF models and string the models into RDF/XML after the models being transferred. 2.5. Previous RDF to CG conversions No other researcher has previously converted from CGs to RDF. However, Corby et al. [3] have converted RDF to CGs in their work of an RDF engine based on Conceptual Graphs. Our research concentrates on CG to RDF conversion, which is more difficult than the other direction due to several CG constructs that are nonexistent in RDF, such as n-adic relationships, lambda expressions, etc [17]. 3. Automated CG to RDF converter The similarity between the CG model and the RDF model makes it theoretically possible to convert a knowledge representation in the CG model to a knowledge representation in the RDF model. In our previous paper, we introduced the conversion theoretically in detail [17]. In this paper, we will describe how we implemented a tool that performs automatic conversion; and discuss the experimental results attained by using the converter to translate some typical CG examples into RDF. The automatic CG to RDF converter was developed in Java to take advantage of CG model manipulation provided by Notio Java packages and RDF model manipulation provided by Jena Java packages. The following is the system diagram of the converter Fig. 3.
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
407
CGIF to RDF converter CGIF
Parse CGIF by Notio
MapCG model into RDF model
Build RDF by Jena
RDF/XML
Fig. 3. System diagram of the converter.
In the converter, we utilize Notio to parse CGIF to acquire all information about the knowledge models to be translated. Then, we applied the translation theory we proposed in [17] to map the CG concepts and relations into RDF resources and properties, and still keep the semantics. During this step, we used Notio to traverse the concepts and relations in CG models and used Jena to create RDF/RDF-S resources and properties, and add these resources and properties into RDF models. Due to the similarity of the two knowledge representation models, there are corresponding Java interface/class representations for corresponding concepts in CG models and RDF models. For example, in Notio, there are Java classes ‘‘Concept’’ and ‘‘Relation’’ to represent concepts and relations in a CG model. And in Jena, there are Java interfaces ‘‘Resource’’ and ‘‘Property’’ to represent resources and properties in an RDF model. These two Java API packages, Notio, and Jena, provide a foundation to manipulate CGs and RDF separately, and we concentrate our work on semantically mapping between the two models. Next, we would like to discuss first how we implement the general issues about the conversion. 1. The basic mapping rules: CG: conceptual relations => RDF: predicates (Properties) CG: concepts (nodes with conceptual relationship arcs pointing away) => RDF: subjects (Resources) CG: concepts (nodes with conceptual relationship arcs pointing to) => RDF: objects (Resources or Literals) To implement this basic mapping rule, after parsing a CG representation in CGIF by the Notio ‘‘Translator’’ class, we basically abstract information contained in a Java object of ‘‘Concept’’ by Notio to create a Java representation of ‘‘Resource’’ by Jena and add the representation of ‘‘Resource’’ to an output RDF model; and abstract information contained in a Java object of ‘‘Relation’’ of Notio to create a Java representation of ‘‘Property’’ of Jena and add the representation of ‘‘Property’’ to the output RDF model. 2. Concatenate URI reference to CGs identifiers. Resources and properties are identified by URI references in RDF. Since the URI references are not required to be retrievable on the World Wide Web, but only to be unique, we make a unique URI reference for each
CGs’ concept or relation by concatenating a URI reference to each CGs’ identifier. It is easy to implement in software by prefixing each CGs’ identifier with a common domain name with document or application names. Since RDF/XML is based on XML syntax, we can use a Jena RDF model method to set the NameSpace prefix to make an RDF model more human readable in RDF/ XML format. In the following examples, we will use ‘‘http://cs.uah.edu/kb/concepts/’’ as the prefix to concatenate with CG concepts’ identifiers to form unique URI references to represent RDF resources that correspond to concepts in CG; and we will use ‘‘http://cs.uah.edu/kb/relations/’’ as the prefix to concatenate CG relations’ identifiers to form a unique URI to represent RDF properties that correspond to relations in CG. 3. Preprocessing CGIF. Some basic structural concepts are common to both CGs and RDF. We preprocess some primitives to make more concise conversion when possible. For example, if a concept is typed as ‘‘Literal’’, the literal string will be set as the value of the property, rather than creating an RDF-S class, and adding the referent as an individual of the class. Another preprocess we implemented in the converter is we preprocessed some representations in input CGIF before providing it to the Notio parser. Our purpose is to enlarge the compatibility of CGIF with Notio parser. For example, a notation ‘‘Employee < Person’’ will be preprocessed as ‘‘(subtype [Employee] [Person])’’ before feeding it into the CGIF parser. 4. Map concept type as RDF-S class, map referent as RDF resource. The converter will map a concept type to a RDF-S class, and add the concept referent to the concept if it exists as an individual resource of the RDF-S class. If there is no referent with the concept, that means any physical entity of the concept type exists; and the converter will still add a resource of the RDF-S class with a special identifier. The above were basic mapping rules we applied in implementing the CGIF to RDF converter. But when considering the CG cases that contain more complex syntax and semantics, it was a much more complex task to make the converter work completely and efficiently in different situations. In the next sub sections, we will discuss how the converter works on some examples with typical CG syntax, and discuss the result we get from the converter.
408
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
3.1. Blank graph An empty CG contains no concepts or conceptual relations [15,16]. A blank graph is represented as an empty string in CGIF. But the mapped RDF model in XML syntax is not an empty file in that it still has header information as an RDF model. 3.2. Singleton A singleton graph contains a single concept without a conceptual relation [15,16]. To convert a CG singleton, we first add the concept type as a RDF-S class into the RDF model, and then add the referent of the concept type as an individual of the RDF-S class. The following example shows the converted RDF model in RDF/XML, if the input CG model in CGIF is ‘‘[Person: ‘John’]’’, ‘‘Person’’ is the concept type, and ‘‘John’’ is the referent to the concept type. ‘‘Person’’ is added into the RDF model as an RDF-S class, and ‘‘John’’ is added into the RDF model as an individual of the ‘‘Person’’ class. The following is the RDF model in RDF/XML format: The header in the above example is automatically generated when using the Jena RDF model writer. To save space and improve clarity, in the following examples, we will only demonstrate the RDF statements in which we are interested. According to the Conceptual Graphs Standard [16], if a concept’s referent field contains a blank, which represents an existential quantifier, the actual referent is a physical entity of type [16]. So if the above CG example modified as:
Notice that an individual of the ‘‘Person’’ class is identified by concatenating the concept type label with a different URI reference prefix ‘‘http://cs.uah.edu/kb/concepts/ any/’’. 3.3. Basic CGs (object is literal or resource) Basic CGs described here are CGs that have simple concepts and relations which can be mapped into RDF directly without complicated handling. For a basic CG with two concepts connected with a relation, as we mentioned in our basic mapping rules, we would add the concept types as RDF-S classes, and add the referents, if they exist, as individual resources of the RDF-S classes; the two individuals will be connected with the property that is mapped from the CG relation. A concept could be typed as ‘‘Literal’’ and has a quoted string as referent. For this type of concept, we would process it as a literal value of the corresponding RDF property, rather than an individual resource typed as ‘‘Literal’’. The next is an example about two basic CGs. The first CG will be converted into RDF, where RDF object is a literal value, and the second CG will be converted into RDF, where RDF object is an RDF resource. The example in CGIF: (name [Employee: ‘employeeID1234’] [Literal: ‘‘John’’]) (belongTo [Employee: ‘employeeID1234’] [Department: ‘departmentID5’]) Converting the above CGIF into RDF model in RDF/ XML, we have: John
CG: [Person] The converted RDF from the converter will be:
Notice that value of the property ‘‘relations:belongTo’’ is an RDF resource, while the value of the property
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
‘‘relations:name’’ is a string value rather than a URI reference identifying an RDF resource. 3.4. CG n-adic relationship to RDF binary relationship In the CG model, a conceptual relation has a relation type and a valence that is a nonnegative integer. The valence of a CG relation could be numbered from 1 to n, and the relation is called n-adic. One difference between the CG model and the RDF model is that an RDF property is always a binary relationship, while a CG relation could be n-ary. Since CG’s binary relationship is common and has been previously demonstrated, in this sub section, how the converter handling CG monadic and n-adic (n > 2) relationship will be discussed. 1. Monadic Relation (valence = 1)When translating a monadic CG relation into a binary RDF relation, a blank node is needed to connect to one end of the RDF relation. When meeting a monadic CG relation, the converter creates a RDF anonymous resource without a URI identifier. The following example illustrate the conversion of a CG monadic relation: CG: (Counterpart [Day]) Converted RDF: Notice that the relation ‘‘relations:Counterpart’’ has an anonymous node as subject. 2. N-ary relation (valence > 2)When translating an n-ary (n > 2) CG relation into a binary RDF relation, a collection node is needed to group concepts on the end of the relation where there are more than one concept. When meeting an n-ary CG relation, the converter will create an RDF collection node, such as Bag, which will contain multiple corresponding resources. The following example illustrates the conversion of a CG conceptual relation of valence 3: CGIF: (Betw [Rock] [Place *x] [Person]) The following is the above CG represented in linear form for better human-readable. LF: [Person] ‹ (Betw)‹1-[Rock] ‹2-[Place] From the LF representation, we can clearly see that the valence of the conceptual relation ‘‘Betw’’ is 3: the concepts ‘‘Rock’’ and ‘‘Place’’ are associated with
409
relationship arc pointing to the relation ‘‘Betw’’, and the concept ‘‘Person’’ is associated with the relationship arc pointing away from the relation ‘‘Betw’’. The semantic meaning of the above example is: ‘‘A person is between a rock and a hard place’’ [16]. A problem with CGIF we found during this research is that CGIF does not reserve semantic meaning as well as LF does: from the above CG in CGIF, we can not tell whether a person is between a rock and a place, or a person and a place are between a rock. The following is the converted RDF from the above example: Notice that a collection type node, rdf:Bag, contains the multiple corresponding resources on one end of the binary relationship, ‘‘relations:Betw’’. 3.5. CG context to RDF reification In the CG model, context is a ‘‘concept that contains a nonblank CG that is used to describe the referent of the concept’’ [16]. A descriptor is used to represent a conceptual graph nested in the referent field of a concept. Context is usually used to describe a situation, proposition, negation, etc. When detecting that a referent is specified by a descriptor, the converter will recursively treat the immediately nested descriptor first and then more deeply nested descriptors. In RDF, reification is used to describe other RDF statements using RDF, such as recording information about who made statements, where and when statements are made, etc [7]. So we use RDF reification to group nested CGs within the upper relation. The following example is about a CG context from Conceptual Graph Standard [16]: CGIF:
410
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
[Proposition: [Cat]<-(Agnt)<-[Chase]-> (Thme)->[Mouse]] Translating the above CG into RDF/XML, we have:
integer [16]. The default quantifier for a concept is the existential represented by a blank. When it meets a quantifier, the converter will create a new type of RDF property, ‘‘quantity’’, and use this as the property to describe the resource, and set the value of the property as the integer after the ‘‘@’’ sign. The following is an example that illustrates the conversion of a CG with a concept containing a typical quantifier: CG: [Person: @5] Converted the above CG into RDF/XML: 5 A new property ‘‘relation:quantify’’ is created in the RDF model to describe the resource, and is set to the value of 5. The symbol ‘‘@every’’ is a special quantifier in the referent field of a concept to represent that the semantics applies to every case of the concept type. For example, the following CG shows that ‘‘every cat is on a mat’’. CG: (On [Cat: @every] [Mat]) Converted RDF/XML:
Notice that the converter refers to a class type as ‘‘Proposition’’, and defines this proposition as ‘‘Proposition_0’’. The number ‘‘0’’ after ‘‘_’’ just gives a unique identifier for this proposition, which allows it to be different from other propositions. The number ‘‘0’’ can be any other number as long as it makes this proposition uniquely identified. In the converter, the number is increased automatically for each use. In the above example, there are two RDF reification statements are created, and each of them is associated with the proposition, then semantically related with the upper relation.
Notice that the relation ‘‘relations:On’’ describes the ‘‘Cat’’, which is an rdfs:Class to represent this kind of thing, rather than an individual resource typed as this class. Since the section about defined quantifiers is still under construction in the Conceptual Graph standard [16], the converter handles the most common situations about quantifiers, however, it should be easy to add more handling addressing other quantifier signs in the converter.
3.6. Quantifier
A lambda express is a CG with zero or more concepts marked as formal parameters [16]. In the CGIF notation, the character k and lambda expressions are represented by a keyword ‘‘lambda’’ followed by a list of pairs of
In CGs, quantity is expressed by a quantifier that is expressed by an ‘‘at’’ sign, ‘‘@’’, followed by an unsigned
3.7. Lambda expression
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
formal parameters. The following is a 2-adic lambda expression with 2 pairs of formal parameters. CGIF: (lambda (Person*x, City*y) [Go *z] (Agnt ?z ?x) (Dest ?z ?y))
411
‘‘rdfs:subClass’’ rather than directly map it as a common user defined RDF relationship called ‘‘subtype’’. The next is an example mapping a CG concept type hierarchy to an RDF Schema class hierarchy. CG: Employee < Person
To convert the above lambda expression into RDF, we would like to keep the parameters as special RDF resources. Lambda expression formal parameters can be replaced by different values in CG models during run-time, while RDF does not have such a mechanism. But we would like to make RDF resources corresponding to CG lambda expression formal parameters special, then later we can still assert these statements using with different CG lambda expression values. The following is the RDF converted from the above CG. Notice that ‘‘City? = x’’ included is to make the RDF resource special so as to make later assertion easier. This is only one possible solution for processing lambda expressions. As long as we can keep the concepts and relations, it should be easy to add more asserted RDF statements by replacing the resources with special signs. 3.8. Preprocessing and limitations Preprocessing CGs before mapping them into RDF may be more efficient and concise for some cases: one reason for doing so is to reformat the CGIF string to suit the Notio parser. The other reason is: for a formal knowledge base represented in CGIF, where a set of concepts and relations are common or have a fundamental meaning in the knowledge base, we would like to preprocess these concepts or relations to mapped to predefined RDF primitives if they exist. For example, we would map a relationship type ‘‘subtype’’ to
RDF: In the converter, the above CG firstly is translated into the following CGIF: (subtype [Employee] [Person]), if the above CG meets the concept type hierarchy pattern. And then if the relationship ‘‘subtype’’ is further detected, the two resources of rdfs:Class are created and rdfs:subClassOf is added to describe the relationship of the two classes. 4. Conclusions and future work We found it is true both theoretically and experimentally that ‘‘there is huge overlap, making the two technologies very comparable and hopefully easily interworkable’’ [1]. We researched the interchangeability and developed an automatic conversion tool that implements the translation between the two models. Though the converter satisfies the conversion; however, additional preprocessing could be added to make the conversion more concise, depending on characteristics of CG models that are going to be converted. The converter is now in alpha version, and can be requested from the author for further testing. Since OWL is used as an open standard for developing large scale ontologies on the Web, and OWL is based on RDF but have more predefined representation primitives to provider better machine interpretability, in our future research we plan to convert CG models into OWL models. References [1] T. Berners-Lee, Conceptual Graphs and the Semantic Web, Design Issues, (web page at
412
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
[5] P. Hayes, B. McBride (Eds.), RDF Semantics, W3C Recommendation 10 February 2004,
[12]
[13]
[14] [15] [16]
[17]
mendation 10 February 2004,
Automated conversion between different knowledge representation formats Haining Yao *, Letha Etzkorn Department of Computer Science, University of Alabama in Huntsville, Huntsville, AL 35899, USA Received 13 December 2004; accepted 6 April 2006 Available online 5 June 2006
Abstract One problem in knowledge based systems is the problem of knowledge sharing. Many systems use proprietary frameworks for storing knowledge, and even those systems that use standard knowledge representation formats have the problem that more than one such format exists. Conceptual Graphs and Resource Description Framework are two general-purpose knowledge representation models. Since they are structurally similar in syntax, concepts, and semantics, converting Conceptual Graph models to Resource Description Framework models without loss of semantic meaning is feasible. In this paper, we introduce a semantic converter which converts knowledge representation in Conceptual Graphs into representation in Resource Description Framework, as an experiment to overcome the barriers in knowledge sharing and reuse due to lack of consensus of knowledge representation formats between these two knowledge representation models. 2006 Elsevier B.V. All rights reserved. Keywords: Knowledge representation; Conceptual graphs; Resource description framework
1. Introduction Knowledge systems have been widely used in many different areas including knowledge acquisition, dynamic composition of services, service matching, etc. In knowledge system applications, domain knowledge is encoded by a wide variety of knowledge representation languages for sharing and reuse [10]. The diversity of knowledge representation forms results in knowledge system developers choosing one formalism over others for a specific application. However, knowledge systems expressed in one form usually cannot be directly incorporated or converted into other forms. Sharing and reusing knowledge expressed in different representations becomes more important as the use of knowledge based systems continues to expand. This involves translating knowledge systems from one representation to another. Manually reformatting knowledge repre*
Corresponding author. Tel.: +1 256 824 5124; fax: +1 256 8246239. E-mail addresses: [email protected] (H. Yao), [email protected] (L. Etzkorn). 0950-7051/$ - see front matter 2006 Elsevier B.V. All rights reserved. doi:10.1016/j.knosys.2006.04.005
sented from one representation model to another is obviously a hard and tedious work for a large knowledge system. So knowledge representation translation tools that can help automate the translation process are needed. In this paper, we will discuss translating knowledge representation between two well-known knowledge representation standards: the Conceptual Graph (CG) model and the Resource Description Framework (RDF) model. During our research we found that CGs and RDF are very similar in concepts, syntax, and semantics [1]. CGs and RDF are both graph models depicted by nodes connected with arcs: in CGs, concept nodes are connected by conceptual relationship arcs; in RDF, resource nodes are connected with property arcs. Both CGs and RDF are theory models deriving formal semantics from the abstract syntax represented by the graph models. Both CGs and RDF are designed to represent domain knowledge, or formal systematic semantics for knowledge sharing and reuse [17]. In our earlier research, we provided preliminary examination of the high level theory for converting CGs into RDF. In this work, we have concentrated primarily on
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
the practical implementation of the conversion from CGs into RDF. By employing our converter, a CG model in Conceptual Graph Interchange Form (CGIF) can be automatically converted into a RDF model in RDF/XML without changing the semantics. In this paper, we discuss the practical aspects of the CG to RDF conversion. We describe the converter we developed to perform this conversion, and discuss the success of this approach as well as its limitations. No other researcher, to our knowledge, has converted from CGs to RDF, although Corbey et al. [3] performed a conversion in the other direction, from RDF to CGs. The conversion from CGs to RDF is more difficult than the reverse since CGs have several constructs and concepts that are nonexistent in RDF (see Section 2.5). The purpose of our work is to augment knowledge sharing and reuse between knowledge models expressed in different representations, here, CGs and RDF. The interchangeability between the two models will benefit the following: it will enable webization of existing CG applications, and knowledge sharing and exchanging will be enhanced. Finally, this allows the comparison of different information processing rules and algorithms for CGs and RDF applications [17]. In this paper, we provide background material on CGs and RDF in Section 2. We illustrate the CGs to RDF converter in Section 3. And finally in Section 4, we conclude our current work and provide thoughts for future research in the area of knowledge representation conversion. 2. CGs and RDF 2.1. CG Conceptual Graphs (CGs) are an abstract representation used to logically model domain knowledge by defining concepts and conceptual relationships between concepts. In the model represented by conceptual graphs, concepts are nodes referring to entities, and conceptual relations are arcs linking concepts together and referring to the conceptual relationship between concepts. A conceptual graph model is basically a graph: a conceptual graph is represented as a bipartite graph. To make CGs machine-processable, Conceptual Graph Interchange Form (CGIF) is employed as the representation for encoding knowledge represented by bipartite graphs into machine-readable character strings. Another conceptual graph model representation is Linear Form (LF) which makes CGs more human-readable and saves space. The following is an example illustrating three CG forms to represent the meaning of ‘‘a person named ‘John’’’. (1) Display Form: (2) CGIF: (Name [Employee: ‘ID1234’] [Literal: ‘‘John’’]) (3) LF: [Employee: ‘ID1234’] fi (Name) fi [Literal: ‘‘John’’]
405
2.2. RDF/RDF-S Resource Description Framework (RDF) is a generalpurpose knowledge representation framework developed by W3C for representing information about resources in the web. RDF is also a graph model that is depicted as a directed labeled graph: a statement is represented by a node for the subject, a node for the object, and an arc for the predicate that is directed from the subject node to the object node. In RDF, each statement is a triple corresponding to a single arc (a predicate) with a beginning node (a subject) and an ending node (an object). The principle idea RDF is based on is that things are naturally described by object-attribute-value triples: resources are described using properties which have values. RDF draws upon ideas from knowledge representation, artificial intelligence, and data management, logic-based knowledge representation, frames, and relational databases [5,7]. RDF is a graph model, in order to be machine-processable, RDF employs Extensible Markup Language (XML) as its normative interchange syntax. Besides the RDF/XML, triple notation is also used for human readable RDF statements: subject, predicate, and object are listed in a triple to describe an RDF statement. One characteristic that distinguishes RDF from other information representation languages is that RDF uses Uniform Resource Identifiers (URI) references as resources’ or properties’ identities in RDF statements. Theoretically, any resource can be described in RDF as long as it can be identified by a URI reference. And the URI reference doesn’t have to be retrievable in the World Wide Web: as long as the URI reference is unique to identify a ‘‘thing’’ whether it is a resource or a property. RDF schema (RDF-S) is the RDF vocabulary description language to be used to provide a further description mechanism to define classes or groups of related resources and the relationships between the resources. RDF-S is a semantic extension of RDF, but the external semantics of RDF-S primitives is not contained in RDF itself. For example, rdfs:Class and rdfs:Property are used to define the class of resources that are RDF classes or RDF properties; and rdfs:subClassOf and rdfs:subPropertyOf are used as properties to define relationship between RDF-S classes. RDF-S defines type systems similar to the type systems of object-oriented programming languages; however RDF-S defines properties in terms of classes of resources, while object-oriented programming languages define the classes in terms of the properties that the instances of the classes may have [5,7] Fig. 1. The following is similar to the example we have shown in Section 2.1 illustrating CG representations. Here, the
Employee: ‘ID1234’
Name
Literal: “John”
Fig. 1. A Conceptual Graph represented in display form.
406
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
http://cs.uah.edu/kb/Person http://www.w3.org/199902/22-rdf-syntax-ns#type http://cs.uah.edu/kb/ID1234 http://cs.uah.edu/kb/Name John
Fig. 2. An RDF represented in graph format.
example is shown in three RDF representations this time: in graph mode expressed by Fig. 2, then in XML, and finally in triples. The three representations have equivalent meaning. (1) Graph format: (2) XML format:
abstract syntax represented by the graphs, and to provide a basis for semantic meaning reasoning. Since CGs and RDF are both theory-models with similar syntactic modeling structures, it is possible to convert CGs to RDF while retaining semantics. 2.4. Notio and Jena Notio [13,14] is a Java API for manipulating CGs. Notio provides facilities to structure CGs, string CGs into CG normative form CGIF and vice versa, to parse CGs represented in CGIF strings into CG model in memory for processing, etc. Jena [6,8], developed in the HP lab, is a Java API for handling RDF models, including building, parsing, and inferencing RDF models, etc. We researched the current available software on manipulating CGs and RDF, and found that these two Java APIs, Notio, and Jena, have been used to construct some successful CG applications and RDF applications, respectively. Since our purpose is to develop an automated conversion tool for translating knowledge models represented in CGs into knowledge models represented in RDF, we incorporated Notio, the CGs’ handling API, and Jena, the RDF handling API, into our converter: Notio packages are used to parse CG models in CGIF and build CG models in memory; and Jena packages are used to build RDF models and string the models into RDF/XML after the models being transferred. 2.5. Previous RDF to CG conversions No other researcher has previously converted from CGs to RDF. However, Corby et al. [3] have converted RDF to CGs in their work of an RDF engine based on Conceptual Graphs. Our research concentrates on CG to RDF conversion, which is more difficult than the other direction due to several CG constructs that are nonexistent in RDF, such as n-adic relationships, lambda expressions, etc [17]. 3. Automated CG to RDF converter The similarity between the CG model and the RDF model makes it theoretically possible to convert a knowledge representation in the CG model to a knowledge representation in the RDF model. In our previous paper, we introduced the conversion theoretically in detail [17]. In this paper, we will describe how we implemented a tool that performs automatic conversion; and discuss the experimental results attained by using the converter to translate some typical CG examples into RDF. The automatic CG to RDF converter was developed in Java to take advantage of CG model manipulation provided by Notio Java packages and RDF model manipulation provided by Jena Java packages. The following is the system diagram of the converter Fig. 3.
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
407
CGIF to RDF converter CGIF
Parse CGIF by Notio
MapCG model into RDF model
Build RDF by Jena
RDF/XML
Fig. 3. System diagram of the converter.
In the converter, we utilize Notio to parse CGIF to acquire all information about the knowledge models to be translated. Then, we applied the translation theory we proposed in [17] to map the CG concepts and relations into RDF resources and properties, and still keep the semantics. During this step, we used Notio to traverse the concepts and relations in CG models and used Jena to create RDF/RDF-S resources and properties, and add these resources and properties into RDF models. Due to the similarity of the two knowledge representation models, there are corresponding Java interface/class representations for corresponding concepts in CG models and RDF models. For example, in Notio, there are Java classes ‘‘Concept’’ and ‘‘Relation’’ to represent concepts and relations in a CG model. And in Jena, there are Java interfaces ‘‘Resource’’ and ‘‘Property’’ to represent resources and properties in an RDF model. These two Java API packages, Notio, and Jena, provide a foundation to manipulate CGs and RDF separately, and we concentrate our work on semantically mapping between the two models. Next, we would like to discuss first how we implement the general issues about the conversion. 1. The basic mapping rules: CG: conceptual relations => RDF: predicates (Properties) CG: concepts (nodes with conceptual relationship arcs pointing away) => RDF: subjects (Resources) CG: concepts (nodes with conceptual relationship arcs pointing to) => RDF: objects (Resources or Literals) To implement this basic mapping rule, after parsing a CG representation in CGIF by the Notio ‘‘Translator’’ class, we basically abstract information contained in a Java object of ‘‘Concept’’ by Notio to create a Java representation of ‘‘Resource’’ by Jena and add the representation of ‘‘Resource’’ to an output RDF model; and abstract information contained in a Java object of ‘‘Relation’’ of Notio to create a Java representation of ‘‘Property’’ of Jena and add the representation of ‘‘Property’’ to the output RDF model. 2. Concatenate URI reference to CGs identifiers. Resources and properties are identified by URI references in RDF. Since the URI references are not required to be retrievable on the World Wide Web, but only to be unique, we make a unique URI reference for each
CGs’ concept or relation by concatenating a URI reference to each CGs’ identifier. It is easy to implement in software by prefixing each CGs’ identifier with a common domain name with document or application names. Since RDF/XML is based on XML syntax, we can use a Jena RDF model method to set the NameSpace prefix to make an RDF model more human readable in RDF/ XML format. In the following examples, we will use ‘‘http://cs.uah.edu/kb/concepts/’’ as the prefix to concatenate with CG concepts’ identifiers to form unique URI references to represent RDF resources that correspond to concepts in CG; and we will use ‘‘http://cs.uah.edu/kb/relations/’’ as the prefix to concatenate CG relations’ identifiers to form a unique URI to represent RDF properties that correspond to relations in CG. 3. Preprocessing CGIF. Some basic structural concepts are common to both CGs and RDF. We preprocess some primitives to make more concise conversion when possible. For example, if a concept is typed as ‘‘Literal’’, the literal string will be set as the value of the property, rather than creating an RDF-S class, and adding the referent as an individual of the class. Another preprocess we implemented in the converter is we preprocessed some representations in input CGIF before providing it to the Notio parser. Our purpose is to enlarge the compatibility of CGIF with Notio parser. For example, a notation ‘‘Employee < Person’’ will be preprocessed as ‘‘(subtype [Employee] [Person])’’ before feeding it into the CGIF parser. 4. Map concept type as RDF-S class, map referent as RDF resource. The converter will map a concept type to a RDF-S class, and add the concept referent to the concept if it exists as an individual resource of the RDF-S class. If there is no referent with the concept, that means any physical entity of the concept type exists; and the converter will still add a resource of the RDF-S class with a special identifier. The above were basic mapping rules we applied in implementing the CGIF to RDF converter. But when considering the CG cases that contain more complex syntax and semantics, it was a much more complex task to make the converter work completely and efficiently in different situations. In the next sub sections, we will discuss how the converter works on some examples with typical CG syntax, and discuss the result we get from the converter.
408
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
3.1. Blank graph An empty CG contains no concepts or conceptual relations [15,16]. A blank graph is represented as an empty string in CGIF. But the mapped RDF model in XML syntax is not an empty file in that it still has header information as an RDF model. 3.2. Singleton A singleton graph contains a single concept without a conceptual relation [15,16]. To convert a CG singleton, we first add the concept type as a RDF-S class into the RDF model, and then add the referent of the concept type as an individual of the RDF-S class. The following example shows the converted RDF model in RDF/XML, if the input CG model in CGIF is ‘‘[Person: ‘John’]’’, ‘‘Person’’ is the concept type, and ‘‘John’’ is the referent to the concept type. ‘‘Person’’ is added into the RDF model as an RDF-S class, and ‘‘John’’ is added into the RDF model as an individual of the ‘‘Person’’ class. The following is the RDF model in RDF/XML format:
CG: [Person] The converted RDF from the converter will be:
Notice that value of the property ‘‘relations:belongTo’’ is an RDF resource, while the value of the property
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
‘‘relations:name’’ is a string value rather than a URI reference identifying an RDF resource. 3.4. CG n-adic relationship to RDF binary relationship In the CG model, a conceptual relation has a relation type and a valence that is a nonnegative integer. The valence of a CG relation could be numbered from 1 to n, and the relation is called n-adic. One difference between the CG model and the RDF model is that an RDF property is always a binary relationship, while a CG relation could be n-ary. Since CG’s binary relationship is common and has been previously demonstrated, in this sub section, how the converter handling CG monadic and n-adic (n > 2) relationship will be discussed. 1. Monadic Relation (valence = 1)When translating a monadic CG relation into a binary RDF relation, a blank node is needed to connect to one end of the RDF relation. When meeting a monadic CG relation, the converter creates a RDF anonymous resource without a URI identifier. The following example illustrate the conversion of a CG monadic relation: CG: (Counterpart [Day]) Converted RDF:
409
relationship arc pointing to the relation ‘‘Betw’’, and the concept ‘‘Person’’ is associated with the relationship arc pointing away from the relation ‘‘Betw’’. The semantic meaning of the above example is: ‘‘A person is between a rock and a hard place’’ [16]. A problem with CGIF we found during this research is that CGIF does not reserve semantic meaning as well as LF does: from the above CG in CGIF, we can not tell whether a person is between a rock and a place, or a person and a place are between a rock. The following is the converted RDF from the above example:
410
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
[Proposition: [Cat]<-(Agnt)<-[Chase]-> (Thme)->[Mouse]] Translating the above CG into RDF/XML, we have:
integer [16]. The default quantifier for a concept is the existential represented by a blank. When it meets a quantifier, the converter will create a new type of RDF property, ‘‘quantity’’, and use this as the property to describe the resource, and set the value of the property as the integer after the ‘‘@’’ sign. The following is an example that illustrates the conversion of a CG with a concept containing a typical quantifier: CG: [Person: @5] Converted the above CG into RDF/XML:
Notice that the converter refers to a class type as ‘‘Proposition’’, and defines this proposition as ‘‘Proposition_0’’. The number ‘‘0’’ after ‘‘_’’ just gives a unique identifier for this proposition, which allows it to be different from other propositions. The number ‘‘0’’ can be any other number as long as it makes this proposition uniquely identified. In the converter, the number is increased automatically for each use. In the above example, there are two RDF reification statements are created, and each of them is associated with the proposition, then semantically related with the upper relation.
Notice that the relation ‘‘relations:On’’ describes the ‘‘Cat’’, which is an rdfs:Class to represent this kind of thing, rather than an individual resource typed as this class. Since the section about defined quantifiers is still under construction in the Conceptual Graph standard [16], the converter handles the most common situations about quantifiers, however, it should be easy to add more handling addressing other quantifier signs in the converter.
3.6. Quantifier
A lambda express is a CG with zero or more concepts marked as formal parameters [16]. In the CGIF notation, the character k and lambda expressions are represented by a keyword ‘‘lambda’’ followed by a list of pairs of
In CGs, quantity is expressed by a quantifier that is expressed by an ‘‘at’’ sign, ‘‘@’’, followed by an unsigned
3.7. Lambda expression
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
formal parameters. The following is a 2-adic lambda expression with 2 pairs of formal parameters. CGIF: (lambda (Person*x, City*y) [Go *z] (Agnt ?z ?x) (Dest ?z ?y))
411
‘‘rdfs:subClass’’ rather than directly map it as a common user defined RDF relationship called ‘‘subtype’’. The next is an example mapping a CG concept type hierarchy to an RDF Schema class hierarchy. CG: Employee < Person
To convert the above lambda expression into RDF, we would like to keep the parameters as special RDF resources. Lambda expression formal parameters can be replaced by different values in CG models during run-time, while RDF does not have such a mechanism. But we would like to make RDF resources corresponding to CG lambda expression formal parameters special, then later we can still assert these statements using with different CG lambda expression values. The following is the RDF converted from the above CG.
RDF:
412
H. Yao, L. Etzkorn / Knowledge-Based Systems 19 (2006) 404–412
[5] P. Hayes, B. McBride (Eds.), RDF Semantics, W3C Recommendation 10 February 2004,
[12]
[13]
[14] [15] [16]
[17]
mendation 10 February 2004,