[Pellet-users] Slow reasoning & getting status info

[Holger Knublauch]

Thanks, Evren.  This explains it.  I am following up with Rinke on the 
TopBraid mailing list [1] to find the best way to avoid such complexity 
pitfalls.

Holger

[1] 
http://groups.google.com/group/topbraid-composer-users/browse_thread/thread/c78ac95685e41c3c

Evren Sirin wrote:
> Sorry, being late to the discussion. See by reply below...
> 
> On 3/29/07 11:26 AM, Rinke Hoekstra wrote:
>> Hi Holger, others,
>>
>> Holger Knublauch wrote:
>>> Rinke Hoekstra wrote:
>>
>>  * snip *
>>
>>>
>>> Here is a test case to illustrate this:
>>>
>>> public class RinkeTestCase extends TestCase {
>>>
>>>     public void testRinke() {
>>>         OntModel ontModel = 
>>> ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
>>>         
>>> ontModel.read("http://www.estrellaproject.org/lkif-core/lkif-core.owl");
>>>         OntModelSpec spec = PelletReasonerFactory.THE_SPEC;
>>>         InfModel infModel = ModelFactory.createOntologyModel(spec, 
>>> ontModel);
>>>         long startTime = System.currentTimeMillis();
>>>         int count = 0;
>>>         StmtIterator it = infModel.listStatements();
>>>         while(it.hasNext()) {
>>>             it.nextStatement();
>>>             count++;
>>>         }
>>>         long endTime = System.currentTimeMillis();
>>>         System.out.println("Elapsed: " + (endTime - startTime));
>>>     }
>>> }
>>
>> I had a look at your code and compared it to Pellet.java in the Pellet 
>> 1.4 distribution. Differences are that TB creates an OntModel, loads 
>> the file, then creates an InfModel with a PeleltReasoner, and iterates 
>> over all statements. Pellet on the other hand, loads the file into a 
>> regular Model and then creates an OntModel with the reasoner and the 
>> Model, but does not iterate over the statements in that model. 
> Yes, that's correct. model.listStatements will reuten *all* possible 
> inferences that Pellet can find. This includes subclasses, equivalent 
> classes, disjoints, complements, types for individuals, property 
> relations, etc. It is normal that this function call is slow and I don't 
> recommend using it unless you really need all the information, e.g. you 
> might do it if you want to materialize all the inferences in a plain RDF 
> model.
>> They rather 'extract' the reasoner from the created OntModel, call 
>> classify() and realize(), again extract a model from the reasoner and 
>> *then* iterate over the statements.
> Yes, the command line version only classifies and realizes (finds the 
> types for individuals) and nothing more.
>>
>> See testRinke2 and testRinke3 below. The first just adjusts the TB way 
>> of handling the model to the Pellet way, but still iterates over the 
>> original model (slow). The second only iterates over the model which 
>> is given back by the reasoner (really fast).
>>
>> The first gives back thousands of statements (I added a counter), and 
>> the second returns only 11 (?).
> The first number makes sense but the second one is not right simply 
> because you are missing a oModel.prepare(); after creating the ontology 
> model. Accessing the KnowledgeBase inside PelletInfGraph can be tricky. 
> If you don't explicitly call the prepare function the underlying KB will 
> not see anything that has been read into the Jena model.
> 
> It might be easier to stick to Jena model rather than going into the 
> details of Pellet classes. You only need to ask a more concentrated 
> query as in model.listStatements( null, RDF.subClassOf, null) which will 
> only trigger a classification and return all the inferred subclass 
> relations.
> 
> Also since LKIF contains imported ontologies retrieving each ontology, 
> parsing and processing RDF statements takes considerable time (network 
> latency, XML parsing, etc.). When I tried right now, loading seemed to 
> take more than the classification itself.
> 
> Cheers,
> Evren
>>
>> Hmmm
>>
>>
>> -Rinke
>>
>>
>>
>>     public void testRinke2() {
>>         Model pModel = null;
>>         ModelReader modelReader = new ModelReader();
>>         pModel = 
>> modelReader.read("http://www.estrellaproject.org/lkif-core/lkif-core.owl"); 
>>
>>         System.out.println("Read ontology");
>>
>>         long startTime1 = System.currentTimeMillis();               
>> OntModel oModel;
>>
>>         oModel = 
>> ModelFactory.createOntologyModel(PelletReasonerFactory.THE_SPEC, pModel);
>>         System.out.println("Created Ontology Model");
>>         OWLReasoner reasoner = ((PelletInfGraph) 
>> oModel.getGraph()).getOWLReasoner();
>>         System.out.println("Got back my reasoner");
>>         long endTime1 = System.currentTimeMillis();
>>         System.out.println("Elapsed: " + (endTime1 - startTime1));
>>                long startTime = System.currentTimeMillis();
>>         int count = 0;
>>         StmtIterator it = oModel.listStatements();
>>                while(it.hasNext()) {
>>             it.nextStatement();
>>             count++;
>>             System.out.println(count);
>>         }
>>         long endTime = System.currentTimeMillis();
>>         System.out.println("Elapsed: " + (endTime - startTime));
>>                   }
>>
>>
>>     public void testRinke3() {
>>         Model pModel = null;
>>         ModelReader modelReader = new ModelReader();
>>         pModel = 
>> modelReader.read("http://www.estrellaproject.org/lkif-core/lkif-core.owl"); 
>>
>>         System.out.println("Read ontology");
>>
>>         long startTime1 = System.currentTimeMillis();               
>> OntModel oModel;
>>
>>         oModel = 
>> ModelFactory.createOntologyModel(PelletReasonerFactory.THE_SPEC, pModel);
>>         System.out.println("Created Ontology Model");
>>         OWLReasoner reasoner = ((PelletInfGraph) 
>> oModel.getGraph()).getOWLReasoner();
>>         System.out.println("Got back my reasoner");
>>         long endTime1 = System.currentTimeMillis();
>>         System.out.println("Elapsed: " + (endTime1 - startTime1));
>>                long startTime = System.currentTimeMillis();
>>         int count = 0;
>>                reasoner.classify();
>>         reasoner.realize();
>>                Model eModel = reasoner.extractModel(false); // not 
>> verbose
>>                StmtIterator it = eModel.listStatements();
>>                while(it.hasNext()) {
>>             it.nextStatement();
>>             count++;
>>             System.out.println(count);
>>         }
>>         long endTime = System.currentTimeMillis();
>>         System.out.println("Elapsed: " + (endTime - startTime));
>>                   }
>>
>>
>>
>>>
>>> This is similar to what we are doing in TopBraid, and it really takes 
>>> minutes to list all triples.  The messages
>>>
>>> Sub Count: 13786
>>> Sat Count: 83
>>>
>>> are printed out after 30 seconds, similar to what Rinke states, but 
>>> then it becomes very slow.
>>>
>>> Assuming Rinke's command line test does a comparable job, then either 
>>> the Pellet-Jena bridge is very inefficient or I am creating the model 
>>> in a wrong way.  Please advise.
>>>
>>> Thanks,
>>> Holger
>>> _______________________________________________
>>> Pellet-users mailing list
>>> Pellet-users at lists.owldl.com
>>> http://lists.owldl.com/mailman/listinfo/pellet-users
>>> _______________________________________________
>>>
>>> Sponsored by Clark & Parsia, LLC http://clarkparsia.com/
>>
>> ------------------------------------------------------------------------
>>
>> _______________________________________________
>> Pellet-users mailing list
>> Pellet-users at lists.owldl.com
>> http://lists.owldl.com/mailman/listinfo/pellet-users
>> _______________________________________________
>>
>> Sponsored by Clark & Parsia, LLC http://clarkparsia.com/
>