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<[email protected]>:
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,
