... | ... | @@ -8,10 +8,9 @@ This plug-in is still in development! Very probably you may experience faulty an |
|
|
These steps are necessary in order to run the plug-in:
|
|
|
* Download the latest version of Protégé Desktop from [http://protege.stanford.edu/](http://protege.stanford.edu/) and follow the installation instructions. Note that the Debugger Plug-In is not compatible with Protégé version 4 and below.
|
|
|
* Install the Ontology Debugger Plugin with Protégé's Update Function```File->Check for Plugins...``` and select *Ontology Debugger* ![installation_plugin](/uploads/19bb8181c61d7982936f275fe877d2b4/installation_plugin.png)
|
|
|
|
|
|
* **Alternatively** you can also download the [latest jar-file](http://isbi.aau.at/ontodebug/plugin) of the *Ontology Debugger* and copy the jar-File into the ```plugins``` subfolder of your Protégé 5 desktop client.
|
|
|
* If your Protégé client is already running, then you have to restart the client to load the plug-In.
|
|
|
* Once your Protégé client has restarted you will see an additional menu entry in ```Tools->Debug Ontology ...``` as shown here: ![debug_ontology_menuentry](/uploads/4d52afa2f4c3591f9e408cb193f85de5/debug_ontology_menuentry.png)
|
|
|
* Once your Protégé client has restarted you will see an additional menu entry in ```Tools->Debug Ontology ...``` as shown here: ![debug_ontology_menuentry](/uploads/4d52afa2f4c3591f9e408cb193f85de5/debug_ontology_menuentry.png)*These three menu items in the Tools menu show that the Ontology Debugger is installed correctly*
|
|
|
|
|
|
# How to use the Ontology Debugger Plug-In in Protégé
|
|
|
The Ontology Debugger's main task is to ***support the user*** in the process of ***finding the faulty axioms*** in [inconsistent and/or incoherent ontologies](http://ontogenesis.knowledgeblog.org/1329).
|
... | ... | @@ -28,21 +27,23 @@ The Ontology Debugger's main task is to ***support the user*** in the process o |
|
|
- **Remark**: The user of the Ontology Debugger is ***not*** required to analyze (1) which entailments (or statements) do or do not hold or why certain entailments (or statements) do or do not hold ***in the faulty input ontology*** or (2) ***why exactly the input ontology is faulty***. The user is just assumed to answer questions about what must or must not hold ***in the intended ontology or domain model***, respectively. Given the answers, the Ontology Debugger will return what must be repaired in the faulty input ontology.
|
|
|
|
|
|
### Step 1: Load the ontology
|
|
|
To demonstrate the features of the Ontology Debugger, we will now try to find the faulty axioms in the ***consistent but incoherent*** [*Koala ontology*](http://protege.stanford.edu/ontologies/koala.owl). Select ```File->Open from URL... ``` and enter the URL http://protege.stanford.edu/ontologies/koala.owl or simply select the URL from the Bookmarks.
|
|
|
To demonstrate the features of the Ontology Debugger, we will now try to find the faulty axioms in the ***consistent but incoherent*** [*Koala ontology*](http://protege.stanford.edu/ontologies/koala.owl).
|
|
|
|
|
|
Select ```File->Open from URL... ``` ,enter the URL http://protege.stanford.edu/ontologies/koala.owl or select the appropriate URL from the Bookmarks.
|
|
|
|
|
|
![koala](/uploads/3de58c1126cd7b4b641a131c28195ca7/koala.PNG)
|
|
|
![koala](/uploads/3de58c1126cd7b4b641a131c28195ca7/koala.PNG)*For our tutorial please select the incoherent Koala ontology from the Bookmarks*
|
|
|
|
|
|
### Step 2: Select a reasoner
|
|
|
The process of formulating queries and finding the faulty axioms the Ontology Debugger requires the usage of a reasoner.
|
|
|
For our example we must therefore also select a reasoner. Please choose the already installed *Hermit Reasoner* in the ```Reasoner``` menu. ![reasoner](/uploads/654ee6fdd1959cc9f947945776142d1b/reasoner.PNG)
|
|
|
For our example we must therefore also select a reasoner. Please choose the already installed *Hermit Reasoner* in the ```Reasoner``` menu. ![reasoner](/uploads/654ee6fdd1959cc9f947945776142d1b/reasoner.PNG)*The Ontology Debugger requires a reasoner. For our tutorial we choose HermiT.*
|
|
|
|
|
|
### Step 3: Open the Ontology Debugger Tab
|
|
|
|
|
|
Once you have loaded the *Koala ontology*, you can open the *Ontology Debugger Tab* by selecting ```Tools->Debug Ontology...``` in the menu. You may also activate the tab by enabling the tab with ```Window->Tabs->Debugger```. The initial layout of the *Ontology Debugger* should look similar to this screenshot:
|
|
|
|
|
|
![step3](/uploads/1b7a63618ffc50cd0cd5dc333b50e3ce/step3.png)
|
|
|
![step3](/uploads/1b7a63618ffc50cd0cd5dc333b50e3ce/step3.png)*The Ontology Debugger Tab after the Koala ontology has been opened*
|
|
|
|
|
|
***Note*** if you do not see this layout or if you see errors then the layout has changed with a new version of the debugger. Please select ```Window->Reset selected tab to default state``` in such a case to display the current layout.
|
|
|
**Note:** if you do not see this layout or if you see errors then the layout has changed with a new version of the debugger. Please select ```Window->Reset selected tab to default state``` in such a case to display the current layout.
|
|
|
|
|
|
### Step 4: Understanding the layout
|
|
|
|
... | ... | @@ -65,7 +66,7 @@ In the mid section the so called **acquired** and **original test cases** of the |
|
|
|
|
|
In the image below we see an example with three Entailed Testcases and one Non Entailed Testcase which have been acquired during the interaction with the user.
|
|
|
|
|
|
![acquired_testcases](/uploads/cd4ad4276d8c4d7f03eca85d6230bcbd/acquired_testcases.PNG)
|
|
|
![acquired_testcases](/uploads/cd4ad4276d8c4d7f03eca85d6230bcbd/acquired_testcases.PNG)*The Acquired Test Cases show us the answers - the yellow background color highlights an inferred axiom*
|
|
|
|
|
|
Below the set of Acquired Test Cases the **Original Test Cases** are shown that are defined beforehand.
|
|
|
|
... | ... | @@ -85,17 +86,17 @@ Let us use now press the button Start to start a new debugging session! |
|
|
The ontology debugger first checks if the ontology is consistent/coherent. Since our Koala ontology is incoherent it will present us the following two statements as part of the first query:
|
|
|
|
|
|
In the Queries view you now will see these two axioms:
|
|
|
![first_two_axioms](/uploads/1e8f5381ed0541131964117598fc6fa9/first_two_axioms.PNG)
|
|
|
![first_two_axioms](/uploads/1e8f5381ed0541131964117598fc6fa9/first_two_axioms.PNG)*Note: if you get other axioms, then you have set different preference values - use the default prefence values (see below) in this tutorial*
|
|
|
|
|
|
##### Possible Ontology Repairs
|
|
|
|
|
|
Let us ignore these two axioms at first and let us concentrate on the lower part presenting the different **Possible Ontology Repairs**.
|
|
|
|
|
|
![possible_ontology_repairs](/uploads/ad82aabc72e11f3c36cdf56d33749e25/possible_ontology_repairs.PNG)
|
|
|
![possible_ontology_repairs](/uploads/ad82aabc72e11f3c36cdf56d33749e25/possible_ontology_repairs.PNG)*Repairs are possible erroneous axioms - we are finished when we get one such repair*
|
|
|
|
|
|
These Possible Ontology Repairs represent sets of possibly faulty axioms and are calculated once the session has been started or each time after the user submits an answer to a query.
|
|
|
|
|
|
If only one Possible Ontology Repair has been found then we have identified the faulty axioms that altogethter explain inconsistency/incoherency in the ontology and the debugging session is finished.
|
|
|
If only one Possible Ontology Repair has been found then we have identified the faulty axioms that altogether explain inconsistency/incoherency in the ontology and the debugging session is finished.
|
|
|
|
|
|
In our example however there have been identified multiple Possible Ontology Repairs by the Ontology Debugger. This means that, given the current information, each one of these sets of possible faulty axioms (on its own) constitutes a possible explanation of the faulty ontology. Each additionally answered query will narrow down the Possible Ontology Repairs.
|
|
|
|
... | ... | @@ -105,7 +106,7 @@ The minimal conflict sets can be viewed in the Ontology Debugger's __Conflicts__ |
|
|
|
|
|
**Note** that the conflict sets can only be calculated using *HS-Tree* and *HS-DAG* as *Diagnosis Engine Type* (selectable in the debuggers preferences).
|
|
|
|
|
|
### Step 5 Answer the first query
|
|
|
### Step 5: Answer the first query
|
|
|
Continuing with the session from above, the queries section shows us the following question to be answered: ```hasDegree Domain Person``` and ```isHardWorking Domain Person```.
|
|
|
|
|
|
These two axioms are to be understood as questions generated from the Ontology Debugger given to us (for this introduction let us assume that we are experts in the domain of Marsupials).
|
... | ... | @@ -124,22 +125,24 @@ The user can deselect her answer by clicking again on the icon. If she is not su |
|
|
|
|
|
In our example we assume that both axioms are correct since only persons can have a degree, i.e. the domain of ```hasDegree``` is ```Person```, and we assume that only persons can be hard-working, i.e. the domain of ```isHardWorking``` is ```Person``` as well. Please note that as soon as the user answers/classifies one axiom the submit button gets active. So the user is not forced to answer all questions.
|
|
|
|
|
|
![step1](/uploads/b16660d4ac3eaa898adce04a71b752a6/step1.png)
|
|
|
![step1](/uploads/b16660d4ac3eaa898adce04a71b752a6/step1.png)*Answer both statements with YES and press the SUBMIT button*
|
|
|
|
|
|
Acknowledging this decision by pressing __Submit__ causes the Ontology Debugger to take the users answers into account for the calculation of a new set of repairs and new set of queries.
|
|
|
Since the calculation may take some time (depending on the size and complexity of the ontology), a window pops up to show the user the progress of the calculation.
|
|
|
|
|
|
Afterwards new Queries and Possible Repair Sets are presented to the user. Both previously given answers are now listed among the __Entailed Testcases__ in the view for Acquired Test Cases in the mid section (see below).
|
|
|
Afterwards new Queries and Possible Repair Sets are presented to the user.
|
|
|
|
|
|
Both previously given answers are now listed among the __Entailed Testcases__ in the view for Acquired Test Cases in the mid section (see below).
|
|
|
|
|
|
![step2](/uploads/b7aca8279cd4c9869d96384382aa39a7/step2.png)
|
|
|
![step2](/uploads/b7aca8279cd4c9869d96384382aa39a7/step2.png)*A new set of Queries is presented to the user*
|
|
|
|
|
|
### Step 6 Answer all queries until the Debugger gives us a solution
|
|
|
### Step 6: Answer all queries until the Debugger gives us a solution
|
|
|
|
|
|
Since the Ontology Debugger has not found a unique solution yet (i.e. there are still multiple Possible Ontology Repairs), the set of faulty axiom sets is updated based on the given query answer after the user presses the Submit-button. This update involves the deletion of faulty axiom sets inconsistent with the given answer and the generation of some new possible faulty axiom sets as a basis for the computation of the next query. If we continue answering the stated questions of the debugger we will finally end up with one Possible Ontology Repair (also known as diagnosis) corresponding to our Acquired Test Cases and Input Ontology.
|
|
|
|
|
|
**Note** that (1) performing adequate modifications to all the axioms in the obtained set of faulty axioms from the Possible Ontology Repair or (2) deleting all these axioms from the ontology is the only possible way of repairing the inconsistency / incoherency of the Input Ontology in the light of the query answers given during the debugging session. In other words, among all possible repairs of the Input Ontology, the one obtained at the end of the debugging session is the only one reflecting your desired domain model, i.e. in this case the domain model of Marsupials you believe is the correct one.
|
|
|
|
|
|
![finalstep](/uploads/3264b384e6aaef83d50c77d11d6da902/finalstep.png)
|
|
|
![finalstep](/uploads/3264b384e6aaef83d50c77d11d6da902/finalstep.png)*At the end of a debugging session the user gets notified that a Repair has been found*
|
|
|
|
|
|
As it can be seen in the image above, our debugging session ended up with a Possible Ontology Repair consisting of 3 faulty axioms:
|
|
|
- [x] ```KoalaWithPhD EquivalentTo Koala and (hasDegree value PhD)```
|
... | ... | @@ -152,7 +155,7 @@ You can reproduce the provided solution either by taking a look at the given ans |
|
|
|
|
|
Note that the axioms ```Quokka SubClassOf Person```as well as ```Koala DisjointWith Person``` among the acquired test cases are axioms **inferred** by the Ontology Debugger that have been presented in queries. That is, these axioms are not listed in the Input Ontology.
|
|
|
|
|
|
### Step 7 Searching the knowledge base
|
|
|
### Step 7: Searching the knowledge base
|
|
|
We can verify that the axiom ```Quokka SubClassOf Person```is indeed an inferred axiom by searching the knowledge base (possibly faulty axioms) for axioms containing the search expression ```Quokka``` using the search bar in the input ontology view.
|
|
|
![search](/uploads/c9ff4e4a0c61c1ddca456abc399a8c23/search.png)
|
|
|
|
... | ... | |