Using Reasoners - Revision history

TaniaTudorache at 02:25, April 19, 2008

2008-04-19T02:25:18Z

TaniaTudorache at 02:13, April 19, 2008

2008-04-19T02:13:19Z

TaniaTudorache at 01:55, April 19, 2008

2008-04-19T01:55:02Z

TaniaTudorache at 01:20, April 19, 2008

2008-04-19T01:20:39Z

TaniaTudorache at 01:14, April 19, 2008

2008-04-19T01:14:42Z

TaniaTudorache at 01:10, April 19, 2008

2008-04-19T01:10:30Z

TaniaTudorache at 01:07, April 19, 2008

2008-04-19T01:07:04Z

TaniaTudorache at 00:55, April 19, 2008

2008-04-19T00:55:39Z

TaniaTudorache at 23:47, April 18, 2008

2008-04-18T23:47:35Z

TaniaTudorache at 23:31, April 18, 2008

2008-04-18T23:31:21Z

← Older revision		Revision as of 02:25, April 19, 2008
Line 119:		Line 119:

	In the image above, Class_2 is displayed as <code>Class_2 (0 / 1)</code> which means that Class_2 had 0 '''asserted types''' and 1 '''inferred type'''.		In the image above, Class_2 is displayed as <code>Class_2 (0 / 1)</code> which means that Class_2 had 0 '''asserted types''' and 1 '''inferred type'''.
		+
		+
		+	== Other resources ==
		+
		+	* [http://protegewiki.stanford.edu/index.php/ProtegeReasonerAPI The Protege Reasoner API]
		+	* [http://protegewiki.stanford.edu/index.php/ProtegeReasonerPlugin How to develop your own direct reasoner plugin]
		+	* [http://www.co-ode.org/resources/tutorials/ProtegeOWLTutorial.pdf Protege-OWL Tutorial]

@@ Line 83: / Line 83: @@
 When computing the inferred types of the individuals by selecting the in menu '''''Reasoning -> Compute inferred types''''', the default behavior is that all inferred types of an individual will be shown in the UI. This means that both the direct and indirect inferred types will be shown.
-To explain better the difference between the '''direct and indirect inferred types''', please consider the following example: <code>Class_A</code> has a subclass <code>Class_B</code>. It was inferred that <code>Individual_1</code> has type <code>Class_B</code>.
+To explain better the difference between the '''direct and indirect inferred types''', please consider the following example: <code>Class_A</code> has been inferred to have a subclass <code>Class_B</code>. It was also inferred that <code>Individual_1</code> has type <code>Class_B</code>.
 <code><pre>
@@ Line 94: / Line 94: @@
 So, the reasoner computed that <code>Individual_1</code> has direct type <code>Class_B</code>, but it also has an indirect type <code>Class_A</code>, because  <code>Class_B</code> is a subclass of <code>Class_A</code>. All the inferred types of <code>Individual_1</code> will be <code>{Class_A, Class_B}</code>.
-As we have mentioned, the default behavior of the Protege-OWL UI is to display all inferred types for an individual. (So, for <code>Individual_1</code> it will show <code>{Class_A, Class_B}</code>.
+As we have mentioned, the default behavior of the Protege-OWL UI is to display all inferred types for an individual. (So, for <code>Individual_1</code> it will show <code>{Class_A, Class_B}</code>).
 <code><pre>
 reasoner.ui.display.direct.types.only=true
 </pre></code>

← Older revision		Revision as of 01:55, April 19, 2008
Line 80:		Line 80:

	==== Configuring the display of direct vs. all inferred types in the user interface ====		==== Configuring the display of direct vs. all inferred types in the user interface ====
		+
		+	When computing the inferred types of the individuals by selecting the in menu '''''Reasoning -> Compute inferred types''''', the default behavior is that all inferred types of an individual will be shown in the UI. This means that both the direct and indirect inferred types will be shown.
		+
		+	To explain better the difference between the '''direct and indirect inferred types''', please consider the following example: <code>Class_A</code> has a subclass <code>Class_B</code>. It was inferred that <code>Individual_1</code> has type <code>Class_B</code>.
		+
		+	<code><pre>
		+	Class_A
		+	\|
		+	\|___ Class_B ------- Individual_1
		+	</pre></code>
		+
		+
		+	So, the reasoner computed that <code>Individual_1</code> has direct type <code>Class_B</code>, but it also has an indirect type <code>Class_A</code>, because <code>Class_B</code> is a subclass of <code>Class_A</code>. All the inferred types of <code>Individual_1</code> will be <code>{Class_A, Class_B}</code>.
		+
		+	As we have mentioned, the default behavior of the Protege-OWL UI is to display all inferred types for an individual. (So, for <code>Individual_1</code> it will show <code>{Class_A, Class_B}</code>.
		+
		+
		+
		+	<code><pre>
		+	reasoner.ui.display.direct.types.only=true
		+	</pre></code>

← Older revision		Revision as of 01:20, April 19, 2008
Line 79:		Line 79:


−	==== ~~Showing only~~ the direct inferred types in the user interface ====	+	==== Configuring the display of direct vs. all inferred types in the user interface ====

← Older revision		Revision as of 01:14, April 19, 2008
Line 79:		Line 79:


−	==== Showing only the direct types in the user interface ====	+	==== Showing only the direct inferred types in the user interface ====

@@ Line 35: / Line 35: @@
 [[Image:OWLPreferences-General.png]]
-=== Classifying the ontology ===
+=== Classifying the ontology with the DIG reasoner ===
 Now you are ready to test the reasoner connection and to classify the ontology.
@@ Line 68: / Line 68: @@
-=== Classifying the ontology ===
+=== Classifying the ontology with the Direct Reasoner ===
 To classify the ontology with the direct reasoner, select the direct reasoner in the '''Reasoning menu''' and select '''Classify Taxonomy'''. You should see a panel with the title made of the reasoner name and  (direct). E.g. for Pellet: '''''Pellet 1.5.1 (direct)''''':
@@ Line 74: / Line 74: @@
 [[Image: PanelPelletDirect.png]]

← Older revision		Revision as of 01:07, April 19, 2008
Line 60:		Line 60:
	Direct reasoner means that the reasoner is invoked from Protege by calling directly the reasoner API, rather than through DIG, which has several limitations, as mentioned before.		Direct reasoner means that the reasoner is invoked from Protege by calling directly the reasoner API, rather than through DIG, which has several limitations, as mentioned before.
	The advantage of using the direct reasoner over the DIG reasoner is that the entire ontology can be "sent" to the reasoner without suffering any of the limitations that DIG has. A possible disadvantage of the direct reasoner is that Protege-OWL and the reasoner share the same memory space. So, you will most likely need to give Protege more memory if you are using the direct reasoner. See instructions for increasing the heap size for Protege [http://protegewiki.stanford.edu/index.php/Setting_Heap_Size here].		The advantage of using the direct reasoner over the DIG reasoner is that the entire ontology can be "sent" to the reasoner without suffering any of the limitations that DIG has. A possible disadvantage of the direct reasoner is that Protege-OWL and the reasoner share the same memory space. So, you will most likely need to give Protege more memory if you are using the direct reasoner. See instructions for increasing the heap size for Protege [http://protegewiki.stanford.edu/index.php/Setting_Heap_Size here].
		+
		+	The direct reasoners are shown in the '''Reasoning menu'''. After the Protege installation, you will see in the Reasoning menu, only one direct reasoner, '''Pellet x.y.z (direct)'''. New direct reasoners can be easily added by implementing a [http://protegewiki.stanford.edu/index.php/ProtegeReasonerPlugin reasoner plugin].
		+
		+	To use a direct reasoner, please select it in the Reasoning menu. For example, the Pellet 1.5.1 direct reasoner is selected in the image below:
		+
		+	[[Image: DirectReasonerMenu.png]]
		+
		+
		+	=== Classifying the ontology ===
		+
		+	To classify the ontology with the direct reasoner, select the direct reasoner in the '''Reasoning menu''' and select '''Classify Taxonomy'''. You should see a panel with the title made of the reasoner name and (direct). E.g. for Pellet: '''''Pellet 1.5.1 (direct)''''':
		+
		+
		+	[[Image: PanelPelletDirect.png]]

← Older revision		Revision as of 00:55, April 19, 2008
Line 3:		Line 3:


−	<em>This ~~tutorial~~ is a brief users guide for using reasoners in Protege-OWL. It assumes a basic working knowledge of Protege-OWL. Please refer first to the [http://www.co-ode.org/resources/tutorials/ProtegeOWLTutorial.pdf Protege-OWL Tutorial] section "4.9 Using a Reasoner". This page explains some additions (e.g. the direct reasoner) that occurred after the publication of the Protege-OWL tutorial.</em>	+	<em>This wiki page is a brief users guide for using reasoners in Protege-OWL. It assumes a basic working knowledge of Protege-OWL. Please refer first to the [http://www.co-ode.org/resources/tutorials/ProtegeOWLTutorial.pdf Protege-OWL Tutorial] section "4.9 Using a Reasoner". This page explains some additions (e.g. the direct reasoner) that occurred after the publication of the Protege-OWL tutorial.</em>


Line 56:		Line 56:

	== Using the Direct Reasoner ==		== Using the Direct Reasoner ==
		+
		+
		+	Direct reasoner means that the reasoner is invoked from Protege by calling directly the reasoner API, rather than through DIG, which has several limitations, as mentioned before.
		+	The advantage of using the direct reasoner over the DIG reasoner is that the entire ontology can be "sent" to the reasoner without suffering any of the limitations that DIG has. A possible disadvantage of the direct reasoner is that Protege-OWL and the reasoner share the same memory space. So, you will most likely need to give Protege more memory if you are using the direct reasoner. See instructions for increasing the heap size for Protege [http://protegewiki.stanford.edu/index.php/Setting_Heap_Size here].

@@ Line 3: / Line 3: @@
-<em>This tutorial assumes a basic working knowledge of Protege-OWL. Please refer first to the [http://www.co-ode.org/resources/tutorials/ProtegeOWLTutorial.pdf Protege-OWL Tutorial] section "4.9 Using a Reasoner". This page explains some additions (e.g. the direct reasoner) that occurred after the publication of the Protege-OWL tutorial.</em>
+<em>This tutorial is a brief users guide for using reasoners in Protege-OWL. It assumes a basic working knowledge of Protege-OWL. Please refer first to the [http://www.co-ode.org/resources/tutorials/ProtegeOWLTutorial.pdf Protege-OWL Tutorial] section "4.9 Using a Reasoner". This page explains some additions (e.g. the direct reasoner) that occurred after the publication of the Protege-OWL tutorial.</em>
@@ Line 9: / Line 9: @@
 == Using the DIG Reasoner ==
 === Getting the DIG-compliant reasoner ===
@@ Line 49: / Line 52: @@
 If instead of that, you see an almost empty panel with a red text: '''''Reasoner Error: Connection refused''''', it means that you have not configured correctly the Reasoner URL in the OWL Preferences or the reasoner is not running.

← Older revision		Revision as of 23:31, April 18, 2008
Line 48:		Line 48:


−	If instead of that, you see an almost empty panel with a red text: "Reasoner Error: Connection refused", it means that you have not configured correctly the Reasoner URL in the OWL Preferences or the reasoner is not running.	+	If instead of that, you see an almost empty panel with a red text: '''''Reasoner Error: Connection refused''''', it means that you have not configured correctly the Reasoner URL in the OWL Preferences or the reasoner is not running.