Hi Brice,
Glad you are sorted, it did look like a namespace problem.
You can define default namespaces and base URIs in the serializations
and of course Jena will respect them. But internally all resources have
fully resolved absolute URIs so that's what you have when working at the
API level.
Dave
On 23/07/13 11:28, Brice Sommacal wrote:
Hi Dave,
Thank you for your support.
Yesterday, I was not able to send a minimal example quickly (that's why I
have firstly been focused on the data).
My component read a set of XML files and create a OWL files (using Jena).
Then, we apply inference rules on it (to create inverse properties and so
far, transitive inference).
When making the minimal example, I have tried to avoid the read/write thing
from XML files and directly populate the model with 4 individuals. And,
transitive inference was working well.
=>So, the problem came from the data.
It was weird because when opening the OWL file within Protégé, everything
was well-displayed. Even when I was using a functionnality to see "inferred
properties values" (by making a right click on an individual) I was able to
see the transitive values.
In fact, the error was about a namespace problem when filling the 2
properties on which I want to run inbference. (see details below)
*Details:* When reading the XML file, we manage to complete the property of
allparents using
tcuaInstance.addProperty(allParentsClassName, modelKB.createResource( "#"
+ getParentUid()));
The parent Resource was created in the modelKB. When outputing the model in
a file, the default namespace and xml:base properties were filled in with
the same namespace. That's why everything was well-displayed in Protégé.
However, I was expecting a similar behavior when using jena inference.
By replacing, the above line by the full URI of the parentResource, the
inference is working well.
tcuaInstance.addProperty(allParentsClassName, modelKB.createResource(
ONTOLOGY_NAMESPACE + getParentUid()));
Thank you again for your support and the directions that you share to help
me resolving this use case,
BR,
Brice
2013/7/22 Dave Reynolds <dave.e.reyno...@gmail.com>
Hi,
That's not a complete, minimal example - there's not enough info there to
create something we can test. There's nothing in that snippet that shows
any transitive inference is possible since we can't see the 3 and 4 other
individuals you are referring to and can't see what properties they have to
start the inference.
If you can create something more complete so we can see an minimal example
then we might be able to help.
One oddity which might be cut/paste issues in your email or might mean
there's a namespace problem ...
In parts of your example you show:
<#TcClass.RBFParamDef>
and in other parts
<http://seamless.pco-**innovation.com/energy/common/**
software/tcua#TcClass.**RBFParamDef<http://seamless.pco-innovation.com/energy/common/software/tcua#TcClass.RBFParamDef>
Unless you have an explicit @base declaration in that Turtle file then
those are two different resources.
Dave
On 22/07/13 15:12, Brice Sommacal wrote:
Hi again,
The transitive properties are well-defined in my ontology:
<owl:ObjectProperty rdf:about="#allparents">
<rdf:type rdf:resource="http://www.w3.**org/2002/07/owl#**
TransitiveProperty <http://www.w3.org/2002/07/owl#TransitiveProperty>
"/>
<rdfs:range rdf:resource="#TCCLASS"/>
<rdfs:label
rdf:datatype="http://www.w3.**org/2001/XMLSchema#string<http://www.w3.org/2001/XMLSchema#string>
"
>allparents</rdfs:label>
<owl:inverseOf rdf:resource="#allchilds"/>
<rdfs:domain rdf:resource="#TCCLASS"/>
<rdfs:comment rdf:datatype="http://www.w3.**
org/2001/XMLSchema#string <http://www.w3.org/2001/XMLSchema#string>"
>parentClassName</rdfs:**comment>
</owl:ObjectProperty>
<owl:ObjectProperty rdf:ID="allchilds">
<rdfs:range rdf:resource="#TCCLASS"/>
<rdf:type rdf:resource="http://www.w3.**org/2002/07/owl#**
TransitiveProperty <http://www.w3.org/2002/07/owl#TransitiveProperty>
"/>
<rdfs:domain rdf:resource="#TCCLASS"/>
<rdfs:label
rdf:datatype="http://www.w3.**org/2001/XMLSchema#string<http://www.w3.org/2001/XMLSchema#string>
"
>allchilds</rdfs:label>
<owl:inverseOf>
<owl:ObjectProperty rdf:ID="allparents"/>
</owl:inverseOf>
</owl:ObjectProperty>
Here are extract from the infModel :
<#TcClass.RBFParamDef>
a pco:BMIDE , owl:Thing , rdfs:Resource , _:b1 , pco:TCCLASS
;
pco:allchilds <
http://seamless.pco-**innovation.com/energy/common/**
software/tcua#TcClass.**RBFOutput<http://seamless.pco-innovation.com/energy/common/software/tcua#TcClass.RBFOutput>
, <
http://seamless.pco-**innovation.com/energy/common/**
software/tcua#TcClass.**RBFExpression<http://seamless.pco-innovation.com/energy/common/software/tcua#TcClass.RBFExpression>
;
pco:childClassName <
http://seamless.pco-**innovation.com/energy/common/**
software/tcua#TcClass.**RBFOutput<http://seamless.pco-innovation.com/energy/common/software/tcua#TcClass.RBFOutput>
, <
http://seamless.pco-**innovation.com/energy/common/**
software/tcua#TcClass.**RBFExpression<http://seamless.pco-innovation.com/energy/common/software/tcua#TcClass.RBFExpression>
;
owl:sameAs <#TcClass.RBFParamDef> .
<
http://seamless.pco-**innovation.com/energy/common/**
software/tcua#TcClass.**RBFParamDef<http://seamless.pco-innovation.com/energy/common/software/tcua#TcClass.RBFParamDef>
a pco:BMIDE , owl:Thing , rdfs:Resource , _:b1 ,
pco:TCCLASS ;
pco:allparents <#TcClass.BusinessElement> ;
pco:className "RBFParamDef" ;
pco:custo "False" ;
pco:description "" ;
pco:isExportable "false"^^xsd:boolean ;
pco:isUninheritable "false"^^xsd:boolean ;
pco:isUninstantiable
"false"^^xsd:boolean ;
pco:parentClassName <#TcClass.BusinessElement> ;
owl:sameAs <
http://seamless.pco-**innovation.com/energy/common/**
software/tcua#TcClass.**RBFParamDef<http://seamless.pco-innovation.com/energy/common/software/tcua#TcClass.RBFParamDef>
.
I expect 3 individuals in pco:allparents and 4 individuals in
pco:allchilds.
Initially, pco:allchilds is populated from pco:childclassname.
Same for pco:allparents with pco:parentClassName.
As you can see, the inferred type values are well retrived. But nothing
about the inference on transitive properties.
Regards,
Brice
2013/7/22 Dave Reynolds <dave.e.reyno...@gmail.com>
Hi Brice,
Using Models with an explicit reasoner or an OntModel with a suitable
OntModelSpec should result in exactly the same inferences.
This list doesn't accept attachments. The thing to do is to cut your
ontology down a minimal complete test case with you then either post
inline
or use a pastebin type service.
Cutting the ontology down to a test case may reveal the answer anyway :)
Dave
On 22/07/13 14:29, Brice Sommacal wrote:
Hello Dave,
Thank you for your answer. However, I didn't figure out why it was not
working.
You were right, I was meaning owl:TransitiveProperty.
My first code fragment was using Model while the second piece of code
was using OntModel. I was thinking that this 2 differents Model may have
incidences on the inference engine.
Updating the OntModelSpec to OWL_DL_MEM_RULE___INF didn't change
anything in the output file. I am able to see the infered type, but
nothing about my transitive properties.
See ontology.owl attached.
Regards,
Brice
2013/7/19 Dave Reynolds <dave.e.reyno...@gmail.com
<mailto:dave.e.reynolds@gmail.****com <dave.e.reyno...@gmail.com>>>
On 19/07/13 15:54, Brice Sommacal wrote:
Hello everyone,
In the past, I was able to execute inference engine to retrieve
transitive
values like the following:
// model intialisation
Model typesModel = ModelFactory.__****createDefaultModel();
typesModel.read(inStream, "RDF");
//function to run inference:
public void applyInference(Model model) throws
FileNotFoundException{
Model modelTemp = model;
Reasoner reasoner = ReasonerRegistry.__**
getOWLMicroReasoner();
reasoner = reasoner.bindSchema(ev6Model);
InfModel infmodel =
ModelFactory.createInfModel(__****reasoner, model);
Model modelTemp2 = ModelFactory.__****
createDefaultModel();
Property prop21 = ev6Model.getProperty(ns+"#__**
parentsType");
for (StmtIterator sti = infmodel.listStatements(null,
prop21, (RDFNode)
null);
sti.hasNext(); ) {
Statement stmt = sti.nextStatement();
modelTemp2.add(stmt);
}
modelTemp.add(modelTemp2);
}
By "transitive" I assume you mean as in owl:TransitiveProperty?
Actually, I'm working on a other project which deal with
OntModel like the
following:
public static OntModel readOntology(File ontoFile) throws
FileNotFoundException
{
Model myModel = null;
FileInputStream inStream = new FileInputStream(ontoFile);
myModel = ModelFactory.__****createDefaultModel();
myModel.read(inStream, "");
OntModel sourceModel =
ModelFactory.__****createOntologyModel(__****
OntModelSpec.OWL_MEM,
myModel);
return sourceModel;
}
I have 2 transitive properties in my model. When I make a call
to the
function which deal with inference, the transitive values are
not returned.
Here is how my inference engine is initialized:
Reasoner reasoner = ReasonerRegistry.__****
getTransitiveReasoner();
reasoner = reasoner.bindSchema(srcModel);
InfModel infmodel = ModelFactory.createInfModel(__**
**reasoner,
kbModel);
Can't see how this code fragment relates to the above code
fragment.
I'll assume that srcModel is the result of a call to readOntology.
The problem is that the TransitiveReasoner only does transitive
closure (and reduction) of the the subClassOf/subPropertyOf
hierarchies. Despite the name it doesn't handle
owl:TransitiveProperty.
You want OWL_MICRO (or better).
I have tried several way to make it works, but I din't figure
out yet:
- Modify the inference engine intialization with Model
instead of OntModel
Should not make any difference.
- Modify the specification with
OntModelSpec.OWL_DL_MEM_RULE__****_INF instead
of OntModelSpec.OWL_MEM
In readOntology? That should work, though then you don't need the
second InfModel wrapper.
- Modify the reasonner from getTransitiveReasonner to
getOwlMicro
That should also work.
I would start with the simplest standalone test which just creates
an OntModel and use OntModelSpec.OWL_MEM_MICRO___****RULE_INF. No
separate InfModel wrappers.
If that works then you can repackage to separate out a readOntology
function however you wish.
If it doesn't work then that suggests a problem with the ontology
or
the test code. [Or a bug in the reasoner but if you have had the
same case work before then hopefully that's not the case.]
Dave
