如何从Jena本体模型中获取推断数据

Question

尝试通过Jena接口使用PelletReasoner仅列出知识(新三元组)。我只想要在应用托盘推理器和InfModel从本体(OWL)后生成的推断数据。目前，我列出了所有的个体-其中包含断言和推断的知识。

那么我怎么能得到只有推断的知识从猫头鹰。提前感谢……

//Inference Logic//
    com.hp.hpl.jena.reasoner.Reasoner reasoner = org.mindswap.pellet.jena.PelletReasonerFactory.theInstance().create();
    Model infModel = ModelFactory.createInfModel(reasoner, ModelFactory.createDefaultModel());
    OntModel model = ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM, infModel);
    try
    {
        inputStream = new FileInputStream(OWL_File);
    }
    catch (FileNotFoundException p)
    {
        p.printStackTrace();
    }
    model.read(inputStream, null, "RDF/XML");

Answer 1

下面的代码创建了一个简单的OntModel类B和a，其中B ⊑A，而i是b类型的个体。我们可以推断，例如，i是A的一个实例，我们将在结果中看到这一点。

import org.mindswap.pellet.jena.PelletReasonerFactory;
import com.hp.hpl.jena.ontology.OntClass;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.ontology.OntModelSpec;
import com.hp.hpl.jena.rdf.model.InfModel;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Statement;
import com.hp.hpl.jena.rdf.model.impl.StmtIteratorImpl;
import com.hp.hpl.jena.util.iterator.ExtendedIterator;
import com.hp.hpl.jena.util.iterator.Filter;
public class JustTheDeductionsPlease {
    public static void main(String[] args) {
        // Create the base model.  B is a subclass of A, and i is an instance of B.
        String NS = "http://example.org/";
        final OntModel model = ModelFactory.createOntologyModel( OntModelSpec.OWL_DL_MEM );
        OntClass a = model.createClass( NS+"A" );
        OntClass b = model.createClass( NS+"B" );
        a.addSubClass( b );
        model.createIndividual( NS+"i", b );
        // Create the inference model.
        InfModel pModel = ModelFactory.createInfModel( PelletReasonerFactory.theInstance().create(), model);
        // An iterator over the statements of pModel that *aren't* in the base model.
        ExtendedIterator<Statement> stmts = pModel.listStatements().filterDrop( new Filter<Statement>() {
            @Override
            public boolean accept(Statement o) {
                return model.contains( o );
            }
        });
        // For convenient printing, we create a model for the deductions.
        // (If stmts were a StmtIterator, we could add it directly.  It's not,
        // so we end up creating a new StmtIteratorImpl, which is kludgey, but
        // it's more efficient than converting the thing to a list.)
        Model deductions = ModelFactory.createDefaultModel().add( new StmtIteratorImpl( stmts ));
        deductions.write( System.out, "TTL" );
    }
}

整个输出有点大，因为有很多纯粹基于owl的结论。我们最清楚地看到纯演绎结果的地方是我们定义的类和个体。注意，例如，B被列为自身和owl:Thing的子类，但不是a的子类(因为a在原始模型中)，并且i的类型是owl:Thing和a，但不是B(因为B也在原始模型中):

<http://example.org/A>
      <http://www.w3.org/2000/01/rdf-schema#subClassOf>
              <http://www.w3.org/2002/07/owl#Thing> , <http://example.org/A> ;
      <http://www.w3.org/2002/07/owl#disjointWith>
              <http://www.w3.org/2002/07/owl#Nothing> ;
      <http://www.w3.org/2002/07/owl#equivalentClass>
              <http://example.org/A> .
<http://example.org/B>
      <http://www.w3.org/2000/01/rdf-schema#subClassOf>
              <http://www.w3.org/2002/07/owl#Thing> , <http://example.org/B> ;
      <http://www.w3.org/2002/07/owl#disjointWith>
              <http://www.w3.org/2002/07/owl#Nothing> ;
      <http://www.w3.org/2002/07/owl#equivalentClass>
              <http://example.org/B> .
<http://example.org/i>
      a       <http://www.w3.org/2002/07/owl#Thing> , <http://example.org/A> ;
      <http://www.w3.org/2002/07/owl#sameAs>
              <http://example.org/i> .