NSByGrounding

From Knoesis wiki
Revision as of 17:03, 22 June 2011 by Pascal (Talk | contribs)

Jump to: navigation, search

Nominal Schema Reasoning by Grounding

This page contains the implementations of nominal schema reasoning using naive and smart grounding.

Introduction

In this page we include the empirical evaluation and implementation of nominal schemas, a new description logics extension. Several ontologies selected from the TONES repository (reference?) were used for this evaluation. For each experiment presented one or more axioms containing nominal schemas were added to each ontology. For both naive and smart implementations, occurences of nominal schemas are grounded with all possible combinations of individuals contained in the knowledge bases. After the grounding reasoning times (using Pellet after grounding) are averaged over 100 runs, and load time is reported separately. We are particularly interested in finding what are the limits of this implementation varying both the number of different nominal schemas and their number of occurrences per axiom.

Testing was performed using a 64-bit Windows 7 computer with an Intel(R) Core(TM) i5 CPU processor. A java JDK 1.5 version, allocating 3GB as the minimun for the java heap and 3.5GB as the maximun, was used for each experiment.

Naive Implementation

Although not very time-efficient this implementation will serve as a baseline for development and testing of more optimised algorithms. It also shows that even the grounding approach can be used for small use cases or for initial testing.

The section includes testing data obtained from different experiments showing the feasibility of this implementation when the number of different nominal schemas per axiom is low.

Java code to ground axioms containing nominal schemas to a given ontology is also included. After the grounding reasoning tasks can be performed with the ontology using any reasoner available just as usual.

Remark: the java program was built for testing purposes only and therefore it is not an optimised generic algorithm.

Ontologies

We present in this section the metrics of the ontologies used for the Naive implementation. Some ontologies were modified, as shown in the table, to better suit test purposes.

Ontology Classes Annotation P. Data P. Object P. Individuals URI Modifications
Fam 4 0 1 11 5 [1] No mod
Swe 189 1 6 25 22 [2] 20 individuals added
Bui 686 15 0 24 42 [3] 40 individuals added
Wor 1842 6 0 31 80 [4] 80 individuals added
Tra 445 2 4 89 183 [5] No mod
FTr 22 2 6 52 368 [6] No mod
Eco 339 2 8 45 482 [7] No mod

Pascal, the 3 last of them are down... I have them in my computer, shall we upload them?

Testing results

This section contains two tables showing the reasoning time results for the ontologies when axioms with different combinations of nominal schemas are added. Every experiment time results are presented in two columns showing loading time for the first and checking satisfiability for the second.

Adding one axiom to each Ontology

For every experiment in this section only one axiom was added to each ontology varying the number of different nominal schemas and their number of appearances.

Ontology No axioms added 1 different nominal schema 2 different nominal schemas 3 different nominal schemas
2 appearances 8 appearances 2 appearances 4 appearances 2 appearances
Fam (5) 0.01 0.00 0.01 0.00 0.01 0.01 0.01 0.00 0.01 0.00 0.04 0.02
Swe (22) 3.58 0.08 3.73 0.07 3.73 0.11 3.85 0.10 3.88 0.11 10.86 1.11
Bui (42) 2.7 0.16 2.5 0.15 2.47 0.15 2.75 0.26 3.05 0.36 1'14 6.68
Wor (82) 0.11 0.04 0.12 0.05 1.48 0.87 1.1 0.55 1.88 1.03 197'12 5'15
Tra (183) 0.05 0.03 0.05 0.02 0.05 0.02 5.76 1.76 9.9 3.73 OOM OOM
FTr (368) 0.03 4.28 0.05 5.32 0.09 5.51 35.53 42.73 1'18 9'30 OOM OOM
Eco (368) 0.04 0.24 0.07 0.02 0.10 0.04 56.59 13.67 53.32 35.35 OOM OOM

Adding several axioms to each Ontology

Two experiments were considered in this section:

Experiment 1: 20 axioms containing one different nominal schema per axiom with two appearances were added to each ontology.

Experiment 2: 10 axioms containing two different nominal schemas per axiom with two appearances each were added to each ontology.


Name No axioms added Experiment 1 Experiment 2
Fam (5) 0.01 0.00 0.01 0.00 0.02 0.01
Swe (22) 3.58 0.08 3.42 0.08 3.73 0.28
Bui (42) 2.7 0.16 2.69 0.25 5.7 3.21
Wor (80) 0.11 0.04 0.23 0.28 12.42 6.88
Tra (183) 0.05 0.03 0.32 0.15 1' 43.54' 43.63
FTr (368) 0.03 4.28 0.52 11.33 OOM OOM
FTr (368) 0.04 0.24 0.65 0.3 OOM OOM

Grounding Tutorial

This section presents java code to ground axioms with nominal schema for a given ontology. OWL API library needs to be added to the classpath for this task.

Create the frame

First the user needs to write down the frame containing the axiom we want to ground to the knowledge base and store in a .owl file. It can be created with any text editor available. This file should be placed in the same folder as our ontology.

Example of frame containing one axiom with one nominal schema and two appearances:

[

rdf:type owl:Class;
rdfs:subClassOf :frameClass1;
owl:intersectionOf(
[ rdf:type owl:Restriction;
owl:onProperty :property1;
owl:someValuesFrom [ rdf:type owl:ObjectVariable; owl:variableId ”v1” ]
]
[ rdf:type owl:Restriction;
owl:onProperty :property2;
owl:someValuesFrom [ rdf:type owl:ObjectVariable; owl:variableId ”v1” ]
]
)

].

The blank node [ rdf:type owl:ObjectVariable; owl:variableId "v1"] represents the nominal schema. It will be replaced and grounded with all individuals in the ontology.

Example of frame containing one axiom with two nominal schemas and two appearances each:

[

rdf:type owl:Class;
rdfs:subClassOf :frameClass1;
owl:intersectionOf(
[ rdf:type owl:Restriction;
owl:onProperty :property1;
owl:someValuesFrom [ rdf:type owl:ObjectVariable; owl:variableId ”v1” ]
]
[ rdf:type owl:Restriction;
owl:onProperty :property2;
owl:someValuesFrom [ rdf:type owl:ObjectVariable; owl:variableId ”v1” ]
]
[ rdf:type owl:Restriction;
owl:onProperty :property3;
owl:someValuesFrom [ rdf:type owl:ObjectVariable; owl:variableId ”v2” ]
]
[ rdf:type owl:Restriction;
owl:onProperty :property4;
owl:someValuesFrom [ rdf:type owl:ObjectVariable; owl:variableId ”v2” ]
)

].

For this second example the program will ground all possible pair combinations for the nominal schemas "v1" and "v2". The number of groundings is equal to the number of individuals raised to the second power (two different nominal schemas: the program will ground all possible combinations).

Remark: all classes, properties, and namespaces in the frame need to be defined in the ontology for a correct performance of the reasoner after the grounding.

Grounding the axioms

The program will start and prompt the user for the folder's path where we have stored the frame and the ontology and then for the names of these. After execution a new file with appear with the same name as the ontology followed with the word "Grounded.owl". The new file contains the same previous ontology with all possible grounded combinations of individuals for the defined frame added at the end. To ground several nominal schemas for a given ontology we just have to run the program several times with the desired frames.

The program is currently only available for Turtle Syntax. A converter of OWL syntax is available in: [8]

Code can be downloaded from: [here] (make code available!)

Smart Grounding

In this section we present results for the empirical evaluation for nominal schema when the optimization proposed in (REFERENCE) is applied comparing the results with the Naive implementation. Three ontologies, also obtained from the TONES repository, are considered in this section.

To apply this Smart Grounding ontologies need to be part of the SROELVn description logics and the nominal schema appearances need to be "safe" as defined also in (REFERENCE).

Ontologies

We present metrics for the three EL ontologies used for the testing in this section. Due to the lack of EL ontologies with their own individuals all individuals for this section were artificially builded for the given ontologies.

Ontology Classes Annotation P. Data P. Object P. Individuals URI Modifications
Rex 552 10 0 6 100 [9] 100 individuals added
Spatial 106 13 0 13 100 [10] 100 individuals added
Xenopus 710 19 0 5 100 [11] 100 individuals added

Testing Results

The next table present the testing results for the ontologies considered in this section. Again results for each experiment are refered in pairs of columns showing loading and checking satisfiability times.

Ontology No ns 1 different ns P. 2 different ns 3 different ns
Rex 0.025 0.009 0.031 0.013 1.689 0.112 OOM OOM
Rex Optimized 0.058 0.023 0.046 0.011 0.053 0.009
Rex 0.035 0.029 0.021 0.014 1.536 0.101 OOM OOM
Rex Optimized 0.018 0.013 0.033 0.007 0.044 0.011
Rex 0.063 0.018 0.07 0.19 1.598 0.112 OOM OOM
Rex Optimized 0.099 0.037 0.083 0.018 0.097 0.063

Grounding Tutorial

For this tutorial we will make an example on how to simplify a frame using the optimisation proposed in (betterUncleForOWL). This ontoogy can only be applied to ontologies that belong to SROELVn profile. All nominal schema simplfied for the optimisation need to appear in a safe environment as defined in (betterUncleForOWL). Although the formal definition of safe environment and safe nominal schema will not be explained in this page we present an example in Turtle syntax to give a general idea about it.

Axiom simplification example

The example presents an axiom with two different nominal schemas both safe.

Original Axiom

The original axiom contains two nominal schemas in the same axiom.

[ rdf:type owl:Class;
rdfs:subClassOf :frameClass0;
owl:intersection(
[ rdf:type owl:Restriction;
owl:onProperty :property1;
owl:someValuesFrom [
owl:intersectionOf(
 :individual1
[ rdf:type owl:Restriction;
owl:onProperty :property2;
owl:someValuesFrom [ owl:type owl:ObjectVariable; owl:hasId "v1" ]
]
)
]
]
[ rdf:type owl:Restriction;
owl:onProperty :property3;
owl:someValuesFrom [
owl:intersectionOf(
 :individual2
[ rdf:type owl:Restriction;
owl:onProperty :property4;
owl:someValuesFrom [ owl:type owl:ObjectVariable; owl:hasId "v2" ]
]
)
]
]
)
].

Add axiom

To perform the simplification first we have to add the next axiom to the ontology:

[ rdf:type owl:Class;
rdfs:subClassOf :frameClass0;
owl:intersectionOf(
[ rdf:type owl:Restriction;
owl:onProperty :property1;
owl:someValuesFrom :individual1
]
 :newClass1
[ rdf:type owl:Restriction;
owl:onProperty :property3;
owl:someValuesFrom :individual3
]
 :newClass0
)
].
 :newClass1 rdf:type owl:Class .
 :newClass2 rdf:type owl:Class .

Ground axioms

Then the next two axioms need to be grounded separately to the ontology.

Axiom 1

[ rdf:type owl:Class;
rdf:subClassOf
[ rdf:type owl:Restriction;
owl:onProperty owl:Universal;
owl:someValuesFrom
[ owl:intersectionOf(
[ rdf:type owl:ObjectVariable; rdf:variableId "v1" ]
 :newClass1
) ]
];
rdf:type owl:Restriction;
owl:onProperty owl:Universal;
owl:someValuesFrom
[ owl:intersection(
 :individual1
[ rdf:type owl:Restriction;
owl:onProperty :p2;
owl:someValuesFrom [rdf:type owl:ObjectVariable; rdf:variableId "v1" ]
] )
]
].

Axiom 2

[ rdf:type owl:Class;
rdf:subClassOf
[ rdf:type owl:Restriction;
owl:onProperty owl:Universal;
owl:someValuesFrom
[ owl:intersectionOf
[ rdf:type owl:ObjectVariable; rdf:variableId "v2" ]
 :newClass1
) ]
];
rdf:type owl:Restriction;
owl:onProperty owl:Universal;
owl:someValuesFrom
[ owl:intersection(
 :individual1
[ rdf:type owl:Restriction;
owl:onProperty :p4;
owl:someValuesFrom [rdf:type owl:ObjectVariable; rdf:variableId "v2" ]
] )
]
].

With this optimisation we break the initial axiom that produces a number of groundings equal to the number of individuals raised to the second (2 different nominal schemas) and we have two axioms each one producing a number of groundings equal to the number of individuals in the knowledge base.

Literature

Acknowledgements

This work was supported by the National Science Foundation under award 1017225 III: Small: TROn---Tractable Reasoning with Ontologies, and by State of Ohio Research Incentive funding in the Kno.e.CoM project. Adila Krisnadhi acknowledges support by a Fulbright Indonesia Presidential Scholarship PhD Grant 2010.

Retrieved from "https://wiki.aiisc.ai/index.php?title=NSByGrounding&oldid=3585"