OwlExporter. Guide for Users and Developers. René Witte Ninus Khamis. Release 2.1 December 26, 2010

Transcription

1 OwlExporter Guide for Users and Developers René Witte Ninus Khamis Release 2.1 December 26, 2010 Semantic Software Lab Concordia University Montréal, Canada

2

3 Contents 1 Introduction to the OwlExporter Overview Installing the OwlExporter Prerequisites Download Compilation Importing the OwlExporter Using the OwlExporter Example Ontology Export Exporting Instances and Relationships Using the OwlExporter Loading The Annie Pipeline Exporting Domain Individuals Exporting Domain Datatype Relationships Exporting Domain Object Property Relationships Exporting NLP Individuals Exporting NLP Object Property Relationships Exporting Object Property Relationships across Domain and NLP Ontolgies Exporting Coreference Chains Document Annotation OwlExporter Run-time Parameters About this document Within this writting we provide the instructions needed to install and run the OwlExporter in a GATE (Cunningham et al., 2002) application in order to export entities of a text corpus as individuals, and datatype and object relationships of a Web Ontology Language (OWL) model (Franz Baader et al., 2007). Acknowledgments The following developers contributed to the design and implementation of the OwlExporter: René Witte, Ninus Khamis, Qiangqiang Li and Thomas Kappler. License The OwlExporter, and resources are published under the GNU General Public License (GUN GPL) 1. 1 GPL, iii

4 Contents iv

5 Chapter 1 Introduction to the OwlExporter 1.1 Overview The General Architecture for Text Engineering (GATE) is a tool used for the processing of natural language documents. 1 The GATE framework architecture can be extended using plug-ins known as a Collection of REusable Objects for Language Engineering (CREOLE). The OwlExporter is a Processing Resource (PR) that allows to largely automate ontology population from text using a GATE application. With the use of a few simple mapping grammar, the OwlExporter is able to populate an existing ontology using the annotations created by the application Witte et al. (2010). In addition to domain-specific concepts, the OwlExporter is also capable of exporting NLP concepts, such as Sentence, NP and VP, and integrating reasoning support for entities that reappear within a given text and are linked together using coreference chains. Figure 1.1: The OwlExporter Processing Resource 1 GATE, 1

6 Chapter 2 Installing the OwlExporter The OwlExporter is implemented using the Protégé OWL-API, and the GATE 5.2 Embedded class library. Note: At present, the installation has been tested under Linux and Windows. 2.1 Prerequisites To deploy the OwlExporter, a number of other (open source) components are needed. The current distribution comes with pre-compiled libraries for the OwlExporter, but to compile and run them you will still need to install a the following: Needed Software: 1. Apache ANT, 2. Sun JDK 6, 3. GATE v5.0 or newer, 4. Protégé-OWL API, Download To download the latest version of the OwlExporter, this documentation and the GATE demo pipeline, please refer to Compilation In order to compile and run the OwlExporter: Modify build.properties in OWLEXPORTER HOME to point to the correct GATE HOME and Protege HOME directories on the local machine. Copy build.properties and build.xml from the GATE build folder in OWLEXPORTER HOME to GATE HOME. Modify the newly copied build.properties in GATE HOME to point to the correct Protege HOME directory on your local machine. Next we will need to compile the OwlExporter, and GATE to include the the protege libraries needed to run the OwlExporter. Compiling the OwlExporter: 2

7 2.4 Importing the OwlExporter 1. cd to OWLEXPORTER HOME 2. ant jar. Compiling the GATE: 1. cd to GATE HOME 2. ant all After performing the steps mentioned above, a Java Archive called OwlExporter.jar is built. This will contain the binaries needed to include the OwlExporter as a CREOLE PR within GATE. A new gate.jar archive is also created, that will include the binaries from Protege needed to run the OwlExporter. 2.4 Importing the OwlExporter In order to run the OwlExporter we first need to import the PR into GATE. Plugins are added to GATE using the Plugin Management Console. The console can be accessed by either selecting File - Manage CREOLE plugins from the menu or the Manage CREOLE plugins toolbar item. Figure 2.1: GATE Known CREOLE Window When in the Plugin Management Console screen, click on the Add a new CREOLE Repository button and using the Open File dialog box navigate to the directory containing the OwlExporter.jar file. After selecting the directory that contains the jar file, the OwlExporter plugin will be added to the list of Known CREOLE Directories. To begin working with the OwlExporter we will also need to select the Load now and/or the Load Always options. After completing the previous steps click on the OK button in order for the OwlExporter to be successfully added to the GATE Developer. Note: If the installation of the OwlExporter plug-in was unsuccessful, the stack trace displaying the nature of the error can be viewed in the Messages tab of the GATE IDE. 3

8 Chapter 3 Using the OwlExporter In Section 3.2, we explain what is needed in order to successfully export entities of a given annotation as individuals for a specific concept in a domain and NLP ontology using an ANNIE (Cunningham et al., 2002) pipeline, an ANNIE domain ontology, an NLP ontology, and the OwlExporter. In Section?? we export additional entities of annotations that are not specific to the ANNIE pipeline, more importantly we explain what is needed in order to successfully export the relationships created by a GATE application as datatype and object properties of a Domain and NLP ontology. Note: To download the latest version of the GATE demo pipeline, and the ontologies, please refer to Example Ontology Export For the demo described below we used two example ontologies: ANNIE Ontology: For the domain ontology we used the demo.owl 1 taxonomic classification that models commonly used concepts in GATE such as Person, Organization and Location. NLP Ontology: The NLP ontology used in the demo contains the concepts Document, Sentence and NP. Additionally, the ontology has the object properties containssentence that has Document as the domain and Sentence as the range, and contains that has Sentence as the domain and NP as the range. 3.2 Exporting Instances and Relationships Using the OwlExporter In this section we will discuss loading the ANNIE pipeline included with the release, and the Jape grammars needed to export entities and relationships of a corpus to concepts and relationships in the domain and NLP ontologies Loading The Annie Pipeline Download the OwlExporterDemo pipeline from owlexporter Extract the tarball in the directory of your choice and load the GATE teamware OwlExporterDemo.xgapp pipeline. Note: The previous steps discussed in Chapter 2 must be completed before being able to load the GATE pipeline. 1 demo.owl is bundled with GATE and can be accessed from the GATE HOME \plugins\ontology\tools \resources directory 4

9 3.2.2 Exporting Domain Individuals 3.2 Exporting Instances and Relationships Using the OwlExporter OwlExportClassDomain: The OwlExporter uses the OwlExportClassDomain annotation to identify the domain annotations of a corpus that need to be exported as instances of their related concepts in the domain Ontology. 1 AnnotationSet as = (gate.annotationset) bindings. get("ann" ); 2 Annotation ann = (gate.annotation)as. iterator (). next (); 3 FeatureMap features = ann.getfeatures (); 4 5 if (ann.getfeatures (). get(" majortype " ). tostring ().comparetoignorecase("person_first") == 0) { 6 features.put(" classname ", "Person" ); 7 features.put(" hasgender ", ann.getfeatures (). get(" minortype " ). tostring ()); 8 String in = doc.getcontent().getcontent( 9 ann.getstartnode (). getoffset (), ann.getendnode().getoffset ()). tostring (); 10 features.put(" instancename ", in ); 11 features.put(" representationid ", ann. getid ()); 12 features.put(" corefchain ", null ); 13 features.put("kind", "Class" ); 14 outputas.add(as. firstnode (), as.lastnode (), " OwlExportClassDomain ", features ); 15 } Note: The value of the classname feature for both the OwlExportClassDomain and OwlExportClassNLP annotations must match the exact name of the mapped-to concept in the ontology. Both the OwlExportClassDomain and OwlExportClassNLP annotations must contain the features shown in Table 3.1 Feature classname instancename corefchain representationid Description This feature is of type String and must match the name of the Concept in the Ontology that the annotated text in the corpus is an instances of. This feature is String type and is the normalized form of the annotated text that needs to be exported. This feature is of type integer and is the ID of the FuzzyChain. This feature is of type integer and is the ID of the annotation that needs to be exported. Table 3.1: Features needed by the OwlExportClassDomain and the OwlExportClassNLP annotations Exporting Domain Datatype Relationships In order for datatype properties to be exported all that is required is the creation of the datatype property in the ontology with a name that matches that of the feature of a given annotation that needs to be exported. Additionally the domain of the datatype property must match the annotation that the feature belongs to, and the range of the property must match the literal type of the information being exported. 1 features.put(" hasgender ", ann.getfeatures (). get(" minortype " ). tostring ()); For example, continuing with the Document example Jape grammar created previously, for the title and sourceurl information to be exported as datatype properties in the ontology we created the datatype properties title and sourceurl that have Document as the domain and xsd:string as the range. And using the features created by the Jape grammar shown in Figure 3.1, the title and sourceurl datatype property relationships are created. Note: No additional annotations are needed in order for the OwlExporter to create datatype property relationships. 5

10 Chapter 3 Using the OwlExporter Exporting Domain Object Property Relationships OwlExportRelationDomain: The OwlExporter uses the OwlExportRelationDomain annotation to identify the domain annotations of a corpus that need to be exported as relationships of their related individuals in the domain Ontology. 1 gate.annotationset domain = (gate.annotationset)bindings. get("dom" ); 2 gate.annotation domainann = (gate.annotation)domain.iterator (). next (); 3 4 gate.annotationset range = (gate.annotationset) bindings. get("ran" ); 5 gate.annotation rangeann = (gate.annotation)range. iterator (). next (); 6 7 gate.annotationset rel = (gate.annotationset) bindings. get("rel" ); 8 gate.annotation relann = (gate.annotation) rel. iterator (). next (); 9 10 String propertyname="livesin"; gate.featuremap features = Factory.newFeatureMap(); 13 features.put(" propertyname ",propertyname); 14 features.put(" domainid ",domainann.getfeatures().get(" representationid " )); 15 features.put("rangeid",rangeann.getfeatures (). get(" representationid " )); 16 features.put("kind", "JAPE" ); outputas.add(rel. firstnode (), rel.lastnode (), " OwlExportRelationDomain ", features ); Both the OwlExportRelationDomain and OwlExportRelationNLP annotations must contain the features shown in Table 3.2 Feature propertyname domainid rangeid kind Description This feature is of type String and must match the name of the related object property in the ontology. This is feature is of type Integer, it is the id of the annotation that is set as the domain of the related object property. This feature is also of type Integer, it is the id of the annotation that is set as the range of the related object property. This features is String type and is used by the OwlExporter to identify annotations that need to be exported as relationships. The value of this feature is always JAPE. Table 3.2: Features needed by the OwlExportRelationDomain and the OwlExportRelationNLP annotations Exporting NLP Individuals OwlExportClassNLP: The OwlExporter uses the OwlExportClassNLP annotation to identify the NLP annotations of a corpus that need to be exported as instances of their related concepts in the NLP Ontology. 1 AnnotationSet as = (gate.annotationset) bindings. get("ann" ); 2 Annotation ann = (gate.annotation)as. iterator (). next (); 3 FeatureMap features = Factory.newFeatureMap(); 4 5 features.put(" classname ", ann.gettype(). tostring ()); 6 features.put(" representationid ", ann. getid ()); 7 features.put(" corefchain ", null ); 8 features.put("kind", "Class" ); 9 String in = doc.getcontent().getcontent( 10 ann.getstartnode (). getoffset (), ann.getendnode().getoffset ()). tostring (); if (ann.gettype(). tostring ().comparetoignorecase("document")==0) { 13 features.put(" instancename ",ann.getfeatures (). get("title" )); 14 } outputas.add(as. firstnode (), as.lastnode (), " OwlExportClassNLP ", features ); Exporting NLP Object Property Relationships OwlExportRelationNLP: The OwlExporter uses the OwlExportRelationNLP annotation to identify the NLP annotations of a corpus that need to be exported as relationships of their related individuals in the NLP Ontology. 6

11 3.2 Exporting Instances and Relationships Using the OwlExporter 1 gate.annotationset sentas = (gate.annotationset) bindings. get("ann" ); 2 gate.annotation sentann = (gate.annotation)sentas. iterator (). next (); 3 AnnotationSet npas = inputas.getcontained(sentas.firstnode(). getoffset (), sentas.lastnode (). getoffset ()). get("np" ); 4 String propertyname="contains"; 5 6 for (Annotation a : npas) { 7 gate.featuremap features = Factory.newFeatureMap(); 8 features.put(" propertyname ",propertyname); 9 features.put(" domainid ", sentann.getid ()); 10 features.put("rangeid",a. getid ()); 11 features.put("kind", "JAPE" ); outputas.add(npas.firstnode(), npas.lastnode()," OwlExportRelationNLP ", features ); 14 } Exporting Object Property Relationships across Domain and NLP Ontolgies OwlExportRelationDomainNLP: The OwlExporter uses the OwlExportRelationDomainNLP annotation to identify the object property relationships that need to be exported between the Domain and NLP ontology. 1 gate.annotationset sentas = (gate.annotationset) bindings. get("ann" ); 2 gate.annotation sentann = (gate.annotation)sentas. iterator (). next (); 3 AnnotationSet domas = inputas.getcontained(sentas.firstnode().getoffset (), sentas.lastnode (). getoffset ()). get(" MentionDomain " ); 4 gate.annotation domann = (gate.annotation)domas.iterator().next(); 5 6 String propertyname="appearsin"; 7 8 for (Annotation a : domas) { 9 gate.featuremap features = Factory.newFeatureMap(); 10 features.put(" propertyname ",propertyname); 11 features.put(" domainid ", a.getfeatures (). get(" representationid " )); 12 features.put("rangeid",sentann.getfeatures (). get(" representationid " )); 13 features.put("kind", "JAPE" ); outputas.add(sentas.firstnode (), sentas.lastnode (), " OwlExportRelationDomainNLP ", features ); 16 } For our example we will create an object property relationship appearsin that links the domain entities to the sentences they appear in. We began by modifying the Domain ontology to import the NLP ontology. This enabled us to create the appearsin relationship in the domain ontology that has Person, Location, and Organization from the domain ontology as the domain and Sentence from the NLP ontology as the range Exporting Coreference Chains The OwlExporter also support modelling entities that reappear in different parts of a corpus, and that are linked together using coreference chains. For example, an NE coreferencer such as the one in ANNIE (Cunningham et al., 2002) can identify the nominal and pronominal coreferences between entities and create chains that link them together. 1 AnnotationSet chain = annotations.get("lookup Chain" ); 2 Annotation ann = (gate.annotation)as. iterator (). next (); 3 FeatureMap features = ann.getfeatures (); 4 5 if (chain==null chain.isempty()) 6 { 7 System.out. println ("chain empty" ); 8 } 9 Integer chainid = null ; Iterator chainit = chain. iterator (); 12 while ( chainit.hasnext()) 13 { 14 Annotation chainann = (Annotation)chainIt. next (); 15 if ((( ArrayList )(chainann.getfeatures (). get("ids" ))). contains (ann.getid ())) 16 chainid = chainann.getid (); 17 } features.put(" corefchain ", chainid ); When the coreferencer identifies entities of a corpus as being part of the same referent or representative an annotation (for example, NP Chain) is created that contains a list of entities that make up a coreference chain. The OwlExporter s OwlExportClassDomain annotation accepts a corefchain feature that contains the ID of the coreference chain as shown in Table 3.3. By including the corefchain feature the OwlExporter: Creates the corefsentencewithid relationship: The corefsentencewithid relationship associates the referent in a chain with the sentences containing the occurrences of the coreferences. 7

12 Chapter 3 Using the OwlExporter Creates the corefstringwithid relationship: The corefstringwithid relationship ties the referent to it the multiple occurrences of its coreferences. Creates the sameas relationship: The OwlExporter establishes the links between the individuals in the ontology using the symmetric owl:sameas property (Franz Baader et al., 2007). This allows the related individuals to be classified by an OWL reasoner as being equivalent Document Annotation In order for the OwlExporter to be aware of the documents that were already processed, a Document concept can be created in either the domain or NLP ontology that contains document instances that store the information of the documents that have been processed. For the exact location of the document a sourceurl datatype property is created that stores the url location of the processed dpciment. In Figure 3.1 we show an example of a Jape grammar that creates a Document annotation that includes the required features shown below: title: Used to store the name of the document sourceurl: Used to store the source url of the document Phase: mention_doc_info Input: Token Options: control = Once Rule: mention_doc_info ({Token}) :ann --> { try { FeatureMap features = Factory.newFeatureMap(); } features.put("title",doc.getname()); features.put("sourceurl",doc.getsourceurl().getfile()); outputas.add((long) 0,doc.getContent().size(), "Document",features); } catch(invalidoffsetexception ioex) { System.out.println(ioEX); } Figure 3.1: An Example of the Doc Info Grammar Note: The OwlExporter uses the title and sourceurl information to track which documents have already been processed. If a document has already been processed a warning message will be displayed. We modified the NLP Ontology by adding a Document concept that the Document annotations in the GATE application will be exported to as individuals of the ontology. Note: The Document instance can be exported in either the Domain or NLP ontology depending on the the design of the ontology OwlExporter Run-time Parameters 8

13 3.2 Exporting Instances and Relationships Using the OwlExporter Run-time Parameters Type Required Description corefchainlist ArrayList The set of coreference chains in the text corpus. debugflag Boolean Run the OwlExporter with or without the debugger. When set to true the OwlExporter prints various messages during different processing stages. exportdomainontology URL The location and filename of the outputed domain ontology. exportnlp boolean Export an NLP ontology or not. exportnlpontology URL The location and filename of the outputed NLP ontology. importdomainontology URL The path of the file that contains the pre-existing domain ontology that the OwlExporter will use to populate and create the exportdomainontology output ontology. importnlpontology URL The path of the file that contains the pre-existing NLP ontology that the OwlExporter will use to populate and create the exportnlpontology output ontology. inputasname String The processing annotation set where the Owl- Exporter will look for the OwlExportClass and OwlExportRelation. multiowlexport Boolean Output a single Owl file or multiple Owl Files that are all imported by a base output ontology. Table 3.3: Summary of OwlExporter Run-time Parameters 9

14 Bibliography H. Cunningham, D. Maynard, K. Bontcheva, and V. Tablan. GATE: an Architecture for Development of Robust HLT Applications. Proceedings of the 40th Anniversary Meeting of the Association for Computational Linguistics (ACL), URL sale/acl02/acl-main.pdf. Diego Calvanese Franz Baader, Deborah L. McGuinness, Daniele Nardi, and Peter F. Patel- Schneider. The Description Logic Handbook: Theory, Implementation, and Applications. Cambridge University Press, René Witte, Ninus Khamis, and Juergen Rilling. Flexible ontology population from text: The owlexporter. In International Conference on Language Resources and Evaluation (LREC), Valletta, Malta, 05/ ELRA. 10