You are viewing a plain text version of this content. The canonical link for it is here.
Posted to users@jena.apache.org by Eric Scott <er...@att.net> on 2011/08/20 18:33:06 UTC

Time performance and reasoners.

I'm working on a project that explores integrating a fairly large pre- 
(or at least extra-) rdf ontology into RDF, the better to link to other 
ontologies.

Code has been written which translates the ontology written into 
proprietary format into rdf triples. It is stored in a TDB database, and 
amounts to about 11 million statements. At this point almost all URIs 
are outside the standard RDF namespaces. It has it's own equivalent of 
subClassOf, for example. We can query the triplestore effectively as-is.

So in order to integrate this ontology with linked RDF data, it'd be 
nice to use things like owl:equivalentProperty to express equivalence 
between say, my:parentClass and rdfs:subClassOf.

The first problem I'm encountering is that when I create a TDB model 
from our 11M triples,  then create an inference model integrated with an 
owl reasoner, the system takes an intractably long time to load - even 
before I declare any relationships of any kind.

Is this expected behavior? Is there a workaround? Would it be better to 
rewrite the Proprietary->RDF translator to substitute say 
rdfs:subClassOf for my:parentClass?

Any help appreciated.

Regards,

Re: Time performance and reasoners.

Posted by Ignazio Palmisano <ip...@gmail.com>.
2011/8/20 Eric Scott <er...@att.net>:
> Thanks for your response.
>
> What's interesting is that so far I haven't asserted any equivalences at
> all. I'm stuck at the point where I'm just trying to get a pulse from an
> inference model built from the original TDB model + owl with no other
> changes.
>
> Also, I'm able to get past this point with the RDFS reasoner, but as I
> understand it, RDFS doesn't accommodate the owl equivalence relations.
>
>

How are you creating the reasoner? The default is for an RDFS
reasoner, I believe, and you might be layering another one on top of
that - or the OWL part itself might be harder to reason with than it
looks...
HTH,
I.

> On 08/20/2011 09:55 AM, Ignazio Palmisano wrote:
>>
>> 2011/8/20 Eric Scott<er...@att.net>:
>>>
>>> I'm working on a project that explores integrating a fairly large pre-
>>> (or
>>> at least extra-) rdf ontology into RDF, the better to link to other
>>> ontologies.
>>>
>>> Code has been written which translates the ontology written into
>>> proprietary
>>> format into rdf triples. It is stored in a TDB database, and amounts to
>>> about 11 million statements. At this point almost all URIs are outside
>>> the
>>> standard RDF namespaces. It has it's own equivalent of subClassOf, for
>>> example. We can query the triplestore effectively as-is.
>>>
>>> So in order to integrate this ontology with linked RDF data, it'd be nice
>>> to
>>> use things like owl:equivalentProperty to express equivalence between
>>> say,
>>> my:parentClass and rdfs:subClassOf.
>>>
>>> The first problem I'm encountering is that when I create a TDB model from
>>> our 11M triples,  then create an inference model integrated with an owl
>>> reasoner, the system takes an intractably long time to load - even before
>>> I
>>> declare any relationships of any kind.
>>>
>>> Is this expected behavior? Is there a workaround? Would it be better to
>>> rewrite the Proprietary->RDF translator to substitute say rdfs:subClassOf
>>> for my:parentClass?
>>>
>> I'm not sure whether this comment is relevant, but it looks to me like
>> yes, renaming from an arbitrary property to rdfs:subClassOf should
>> help; I can imagine a few reasoners:
>> a) having trouble understanding that these property assertions are not
>> ABox axioms but TBox axioms (a bunch of tableaux optimizations cannot
>> be applied safely when ABoxes exist, I believe, so reasoners would
>> switch them off)
>> b) having to reason about the equivalent properties as well: wherever
>> an existing hierarchy is already in the ontology, your properties will
>> be asserted as well; any domain/range would come into play as well,
>> complicating things while the intention does not appear to be to
>> change the interpretation
>> c) reasoners may consider the subjects and objects of these properties
>> as both classes (because they appear in triples with rdfs:subClassOf)
>> and individuals (because they appear in triples with some other
>> property); many of the reasoners I've had experience with start
>> creaking at the joints with large number of individuals.
>>
>> Take this with a pinch of salt :-) renaming might pose other problems
>> of which I'm not aware.
>> HTH,
>> I.
>>
>>> Any help appreciated.
>>>
>>> Regards,
>>>
>
>

Re: Time performance and reasoners.

Posted by Dave Reynolds <da...@gmail.com>.
On 20/08/2011 18:39, Eric Scott wrote:
> Thanks for your response.
>
> What's interesting is that so far I haven't asserted any equivalences at
> all. I'm stuck at the point where I'm just trying to get a pulse from an
> inference model built from the original TDB model + owl with no other
> changes.
>
> Also, I'm able to get past this point with the RDFS reasoner, but as I
> understand it, RDFS doesn't accommodate the owl equivalence relations.

I assume from this that you are using the built in Rule reasoners rather 
than Pellet.

The rule reasoners all work in memory, if you run them over a TDB store 
all that happens is that all the queries will run much slower but you 
get no additional scaling. So a first step would be to load the data 
into a memory model before trying any inference.

Then make sure you are using OWL Micro as the OWL configuration, that 
hits a much better coverage/performance trade-off than the others.

As to why the reasoner is having to do a lot of work on your 
mostly-owl-free data it is hard to tell. Would need a characterization 
of what is actually in there.

As Ignazio says, make sure you aren't layer reasoners on top of each 
other by accident.

It is a known limitation of the default Jena reasoners that they don't 
scale well. Given some source of funding then improving the rule systems 
for scaling and functionality would be a major priority :)

Dave

>
> On 08/20/2011 09:55 AM, Ignazio Palmisano wrote:
>> 2011/8/20 Eric Scott<er...@att.net>:
>>> I'm working on a project that explores integrating a fairly large
>>> pre- (or
>>> at least extra-) rdf ontology into RDF, the better to link to other
>>> ontologies.
>>>
>>> Code has been written which translates the ontology written into
>>> proprietary
>>> format into rdf triples. It is stored in a TDB database, and amounts to
>>> about 11 million statements. At this point almost all URIs are
>>> outside the
>>> standard RDF namespaces. It has it's own equivalent of subClassOf, for
>>> example. We can query the triplestore effectively as-is.
>>>
>>> So in order to integrate this ontology with linked RDF data, it'd be
>>> nice to
>>> use things like owl:equivalentProperty to express equivalence between
>>> say,
>>> my:parentClass and rdfs:subClassOf.
>>>
>>> The first problem I'm encountering is that when I create a TDB model
>>> from
>>> our 11M triples, then create an inference model integrated with an owl
>>> reasoner, the system takes an intractably long time to load - even
>>> before I
>>> declare any relationships of any kind.
>>>
>>> Is this expected behavior? Is there a workaround? Would it be better to
>>> rewrite the Proprietary->RDF translator to substitute say
>>> rdfs:subClassOf
>>> for my:parentClass?
>>>
>> I'm not sure whether this comment is relevant, but it looks to me like
>> yes, renaming from an arbitrary property to rdfs:subClassOf should
>> help; I can imagine a few reasoners:
>> a) having trouble understanding that these property assertions are not
>> ABox axioms but TBox axioms (a bunch of tableaux optimizations cannot
>> be applied safely when ABoxes exist, I believe, so reasoners would
>> switch them off)
>> b) having to reason about the equivalent properties as well: wherever
>> an existing hierarchy is already in the ontology, your properties will
>> be asserted as well; any domain/range would come into play as well,
>> complicating things while the intention does not appear to be to
>> change the interpretation
>> c) reasoners may consider the subjects and objects of these properties
>> as both classes (because they appear in triples with rdfs:subClassOf)
>> and individuals (because they appear in triples with some other
>> property); many of the reasoners I've had experience with start
>> creaking at the joints with large number of individuals.
>>
>> Take this with a pinch of salt :-) renaming might pose other problems
>> of which I'm not aware.
>> HTH,
>> I.
>>
>>> Any help appreciated.
>>>
>>> Regards,
>>>
>


Re: Time performance and reasoners.

Posted by Eric Scott <er...@att.net>.
Thanks for your response.

What's interesting is that so far I haven't asserted any equivalences at 
all. I'm stuck at the point where I'm just trying to get a pulse from an 
inference model built from the original TDB model + owl with no other 
changes.

Also, I'm able to get past this point with the RDFS reasoner, but as I 
understand it, RDFS doesn't accommodate the owl equivalence relations.


On 08/20/2011 09:55 AM, Ignazio Palmisano wrote:
> 2011/8/20 Eric Scott<er...@att.net>:
>> I'm working on a project that explores integrating a fairly large pre- (or
>> at least extra-) rdf ontology into RDF, the better to link to other
>> ontologies.
>>
>> Code has been written which translates the ontology written into proprietary
>> format into rdf triples. It is stored in a TDB database, and amounts to
>> about 11 million statements. At this point almost all URIs are outside the
>> standard RDF namespaces. It has it's own equivalent of subClassOf, for
>> example. We can query the triplestore effectively as-is.
>>
>> So in order to integrate this ontology with linked RDF data, it'd be nice to
>> use things like owl:equivalentProperty to express equivalence between say,
>> my:parentClass and rdfs:subClassOf.
>>
>> The first problem I'm encountering is that when I create a TDB model from
>> our 11M triples,  then create an inference model integrated with an owl
>> reasoner, the system takes an intractably long time to load - even before I
>> declare any relationships of any kind.
>>
>> Is this expected behavior? Is there a workaround? Would it be better to
>> rewrite the Proprietary->RDF translator to substitute say rdfs:subClassOf
>> for my:parentClass?
>>
> I'm not sure whether this comment is relevant, but it looks to me like
> yes, renaming from an arbitrary property to rdfs:subClassOf should
> help; I can imagine a few reasoners:
> a) having trouble understanding that these property assertions are not
> ABox axioms but TBox axioms (a bunch of tableaux optimizations cannot
> be applied safely when ABoxes exist, I believe, so reasoners would
> switch them off)
> b) having to reason about the equivalent properties as well: wherever
> an existing hierarchy is already in the ontology, your properties will
> be asserted as well; any domain/range would come into play as well,
> complicating things while the intention does not appear to be to
> change the interpretation
> c) reasoners may consider the subjects and objects of these properties
> as both classes (because they appear in triples with rdfs:subClassOf)
> and individuals (because they appear in triples with some other
> property); many of the reasoners I've had experience with start
> creaking at the joints with large number of individuals.
>
> Take this with a pinch of salt :-) renaming might pose other problems
> of which I'm not aware.
> HTH,
> I.
>
>> Any help appreciated.
>>
>> Regards,
>>


Re: Time performance and reasoners.

Posted by Ignazio Palmisano <ip...@gmail.com>.
2011/8/20 Eric Scott <er...@att.net>:
> I'm working on a project that explores integrating a fairly large pre- (or
> at least extra-) rdf ontology into RDF, the better to link to other
> ontologies.
>
> Code has been written which translates the ontology written into proprietary
> format into rdf triples. It is stored in a TDB database, and amounts to
> about 11 million statements. At this point almost all URIs are outside the
> standard RDF namespaces. It has it's own equivalent of subClassOf, for
> example. We can query the triplestore effectively as-is.
>
> So in order to integrate this ontology with linked RDF data, it'd be nice to
> use things like owl:equivalentProperty to express equivalence between say,
> my:parentClass and rdfs:subClassOf.
>
> The first problem I'm encountering is that when I create a TDB model from
> our 11M triples,  then create an inference model integrated with an owl
> reasoner, the system takes an intractably long time to load - even before I
> declare any relationships of any kind.
>
> Is this expected behavior? Is there a workaround? Would it be better to
> rewrite the Proprietary->RDF translator to substitute say rdfs:subClassOf
> for my:parentClass?
>

I'm not sure whether this comment is relevant, but it looks to me like
yes, renaming from an arbitrary property to rdfs:subClassOf should
help; I can imagine a few reasoners:
a) having trouble understanding that these property assertions are not
ABox axioms but TBox axioms (a bunch of tableaux optimizations cannot
be applied safely when ABoxes exist, I believe, so reasoners would
switch them off)
b) having to reason about the equivalent properties as well: wherever
an existing hierarchy is already in the ontology, your properties will
be asserted as well; any domain/range would come into play as well,
complicating things while the intention does not appear to be to
change the interpretation
c) reasoners may consider the subjects and objects of these properties
as both classes (because they appear in triples with rdfs:subClassOf)
and individuals (because they appear in triples with some other
property); many of the reasoners I've had experience with start
creaking at the joints with large number of individuals.

Take this with a pinch of salt :-) renaming might pose other problems
of which I'm not aware.
HTH,
I.

> Any help appreciated.
>
> Regards,
>