Jena

Unterpunkte dieser Seite

• Transitive reasoner
Provides support for storing and traversing class and property lattices. This implements just the transitive and symmetric properties of rdfs:subPropertyOf and rdfs:subClassOf.
• RDFS rule reasoner
Implements a configurable subset of the RDFS entailments.
• OWL, OWL Mini, OWL Micro Reasoners
A set of useful but incomplete implementation of the OWL/Lite subset of the OWL/Full language.
• DAML micro reasoner
Used internally to enable the legacy DAML API to provide minimal (RDFS scale) inferencing.
• Generic rule reasoner
A rule based reasoner that supports user defined rules. Forward chaining, tabled backward chaining and hybrid execution strategies are supported.

String NS = "urn:x-hp-jena:eg/";
        
// Build a trivial example data set
Model rdfsExample = ModelFactory.createDefaultModel();
Property p = rdfsExample.createProperty(NS, "p");
Property q = rdfsExample.createProperty(NS, "q");
rdfsExample.add(p, RDFS.subPropertyOf, q);
rdfsExample.createResource(NS+"a").addProperty(p, "foo");

Reasoner reasoner = ReasonerRegistry.getRDFSReasoner();

InfModel inf = ModelFactory.createInfModel(reasoner, rdfsExample);

Resource a = inf.getResource(NS+"a");

System.out.println("Statement: " + a.getProperty(q));

static {
        theInstance = new PelletReasonerFactory();
        
        THE_SPEC = new OntModelSpec( OntModelSpec.OWL_MEM );        
        THE_SPEC.setReasonerFactory( theInstance );
        
        ReasonerRegistry.theRegistry().register( PelletReasonerFactory.theInstance() );
	}

model = ModelFactory.createOntologyModel( PelletReasonerFactory.THE_SPEC, plainModel );

reasoner = ((PelletInfGraph) model.getGraph()).getOWLReasoner();

import java.io.FileNotFoundException;

import org.mindswap.pellet.KnowledgeBase;
import org.mindswap.pellet.jena.PelletInfGraph;
import org.mindswap.pellet.jena.PelletReasonerFactory;

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.Resource;
import com.hp.hpl.jena.reasoner.Reasoner;
import com.hp.hpl.jena.util.FileManager;
import com.hp.hpl.jena.vocabulary.RDF;

public class Main {
	
	/**
	 * @param args
	 * @throws FileNotFoundException 
	 */
	public static void main(String[] args) throws FileNotFoundException {

		
		Model schema = FileManager.get().loadModel("file:data/owlDemoSchema.xml");
	    Model data = FileManager.get().loadModel("file:data/owlDemoData.xml");
	    //Reasoner reasoner = ReasonerRegistry.getOWLReasoner();
	    Reasoner reasoner = PelletReasonerFactory.theInstance().create();
	    reasoner = reasoner.bindSchema(schema);
	    InfModel infmodel = ModelFactory.createInfModel(reasoner, data);
	    
	    // ABox consistency
	    PelletInfGraph graph = (PelletInfGraph)infmodel.getGraph();
	    graph.prepare();
	    
	    KnowledgeBase kb = graph.getKB();
	    
	    // ensureConsistency ensures by throwing an exception if the graph
	    // is not consistent
	    kb.ensureConsistency();
	    
	    Resource gamingComputer = infmodel.getResource("urn:x-hp:eg/GamingComputer");
	    Resource whiteBox = infmodel.getResource("urn:x-hp:eg/whiteBoxZX");
	    
	    if (infmodel.contains(whiteBox, RDF.type, gamingComputer)) {
	        System.out.println("White box recognized as gaming computer");
	    } else {
	        System.out.println("Failed to recognize white box correctly");
	    }
	}

}

Model schema = FileManager.get().loadModel("file:data/owlDemoSchema.owl");
Model data = FileManager.get().loadModel("file:data/owlDemoData.rdf");
//Reasoner reasoner = ReasonerRegistry.getOWLReasoner();
Reasoner reasoner = PelletReasonerFactory.theInstance().create();
reasoner = reasoner.bindSchema(schema);

InfModel infmodel = ModelFactory.createInfModel(reasoner, data);

// ABox consistency
PelletInfGraph graph = (PelletInfGraph)infmodel.getGraph();
graph.prepare();

KnowledgeBase kb = graph.getKB();

// ensureConsistency ensures by throwing an exception if the graph
// is not consistent
kb.ensureConsistency();

Resource gamingComputer = infmodel.getResource("urn:x-hp:eg/GamingComputer");
Resource whiteBox = infmodel.getResource("urn:x-hp:eg/whiteBoxZX");

if (infmodel.contains(whiteBox, RDF.type, gamingComputer)) {
	System.out.println("White box recognized as gaming computer");
} else {
	System.out.println("Failed to recognize white box correctly");
}

String syntax = FileUtils.guessLang(mappedURI) ;

Model model = ModelFactory.createDefaultModel() ;

model.read(in.getInput(), baseURI, syntax) ;

if ( this.cacheModelLoads )
	modelCache.put(filenameOrURI, model) ;
return model;

Add RDF statements represented in language lang to the model.
Predefined values for lang are "RDF/XML", "N-TRIPLE",
"TURTLE" (or "TTL") and "N3". 

An RDF Model.
<p>
    An RDF model is a set of Statements.  Methods are provided for creating
    resources, properties and literals and the Statements which link them,
    for adding statements to and removing them from a model, for
    querying a model and set operations for combining models.
<p>
    Models may create Resources [URI nodes and bnodes]. Creating a Resource does
    <i>not</i> make the Resource visible to the model; Resources are only "in" Models
    if Statements about them are added to the Model. Similarly the only way to "remove"
    a Resource from a Model is to remove all the Statements that mention it.
<p>
    When a Resource or Literal is created by a Model, the Model is free to re-use an
    existing Resource or Literal object with the correct values, or it may create a fresh
    one. [All Jena RDFNodes and Statements are immutable, so this is generally safe.]
<p>
    This interface defines a set of primitive methods.  A set of
    convenience methods which extends this interface, e.g. performing
    automatic type conversions and support for enhanced resources,
    is defined in {@link ModelCon}.</P>

// create an empty model
Model model = ModelFactory.createDefaultModel();

model.register(new LogModelChangedListener());

// create the resource
Resource johnSmith = model.createResource(personURI);

// add the property
johnSmith.addProperty(VCARD.FN, fullName);

public Graph getGraph()
        { return graph; }

public long size()  
        { return graph.size(); }

    public boolean isEmpty()
        { return graph.isEmpty(); }

public boolean contains( Statement s )    
        { return graph.contains( s.asTriple() ); }

// containsNode(): true iff the graph contains a triple in which 
// n appears somewhere. if n is a fluid node, it is not defined
// whether true or false is returned, so don't do that.
public boolean containsResource( RDFNode r )
        { return graph.queryHandler().containsNode( r.asNode() ); }

public Model add( Resource s, Property p, RDFNode o )  {
        modelReifier.noteIfReified( s, p, o );
        graph.add( Triple.create( s.asNode(), p.asNode(), o.asNode() ) );
        return this;
    }

In the case of RDF, one natural technique is to translate the RDF statements
into a graph notation and then view that using standard graph visualization
tools (such as GraphViz developed at AT&T [1]). There have been a number
of implementations of this approach - see for example Pietriga’s IsaViz [9]
or Brinkley’s RDFViz [2]. There are also several graph visualization tools
designed for use with ontologies - see for example the range of plugins for
the Prot´eg´e ontology editor [10].

 public Reasoner create() {
        return new PelletReasoner( this );
    }

Model tbox = ModelLoader.loadModel("schema.owl");
Model abox = ModelLoader.loadModel("data.rdf");

Model tbox = ModelLoader.loadModel("schema.owl");
Model abox = ModelLoader.loadModel("data.rdf");

public Reasoner bindSchema( Graph graph ) throws ReasonerException {
        return new PelletReasoner( graph, factory );
    }

    public Reasoner bindSchema( Model model ) throws ReasonerException {
        return bindSchema( model.getGraph() );
    }

reasoner = reasoner.bindSchema(schema);

public InfGraph bind( Graph graph ) throws ReasonerException {
        log.debug("In bind!");
        return new PelletInfGraph( graph, this );
    }
    
    public InfModel bind( Model model ) throws ReasonerException {
        log.debug("In bind!");
    	return new InfModelImpl( bind( model.getGraph() ) );
    }

InfModel infmodel = ModelFactory.createInfModel(reasoner, data);

 public static InfModel createInfModel( Reasoner reasoner, Model model ) {
         InfGraph graph = reasoner.bind(model.getGraph());
         return new InfModelImpl(graph);
    }
	

 public PelletInfGraph(Graph graph, PelletReasoner pellet) {
	super(graph, pellet);

	reasoner = new OWLReasoner();
	nodeMapper = new ATermToNodeMapper();
	
	// we want a union of the input graph and reasoner schema
	if (pellet.getSchema() != null) {
		DisjointMultiUnion union = new DisjointMultiUnion( graph );
		union.addGraph( pellet.getSchema() );
		fdata = new FGraph( union );
	}

	kb = reasoner.getKB();

	rebind();
}

Let me first answer the second question which will help you to solve the 
first problem. KnowledgeBase is the internal Pellet representation for a 
knowledge base. The information it stores is equivalent to a Jena Model 
but uses different internal data structures (based on ATerm library). 
KnowledgeBase class caches various different information (satisfiability 
status of classes, subsumption relation between classes, etc.) to 
optimize query answering. However, these caches are invalidated when 
KnowledgeBase is changed and needs to be recomputed.  OWLReasoner is a 
wrapper around the KnowledgeBase class that simply converts the 
parameters and results between Jena and Pellet. If you load a model to 
OWLReasoner and then change the model then you need to reload the model 
again. More specifically, you will want to reasoner.clear() and then 
reasoner.load(model) again. Then you can use the functions provided by 
OWLReasoner to query the KB. You will never want to use KnowledgeBase 
unless you want go into the specifics of Pellet. PelletReasoner on the 
onther hand is an implementation of Jena Reasoner interface. You hook 
PelletReasoner to an existing Jena model and when you call any Jena 
function, e.g. c1.listSubClasses(), the answer is generated by Pellet. 
The changes to the model are automatically recognized and internal 
structures are updated accordingly. PelletReasoner provides much easier 
integration with Jena but what you lose is the control over when and how 
reasoning is done. PelletReasoner will classify the whole ontology 
whenever you make a change (actually when you ask a question after a 
change). With OWLReasoner you can determine when you want to classify or 
realize (find the instances of each class).

@ARTICLE{Baader00anoverview,
    author = {Franz Baader and Ulrike Sattler},
    title = {An overview of tableau algorithms for description logics},
    journal = {Studia Logica},
    year = {2000},
    volume = {69},
    pages = {2001}
}

package main;

import java.io.FileNotFoundException;

import org.mindswap.pellet.jena.PelletReasonerFactory;

import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.ontology.OntModelSpec;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.reasoner.ReasonerFactory;
import com.hp.hpl.jena.reasoner.ReasonerRegistry;
import com.hp.hpl.jena.util.FileManager;
import com.hp.hpl.jena.vocabulary.RDF;

public class Main {
	
	/**
	 * @param args
	 * @throws FileNotFoundException 
	 */
	public static void main(String[] args) throws FileNotFoundException {
		
		// The following code is performed by the part that hooks up the
		// pellet specific classes with the jena api
		//
		
		// this uri might go into some reasoner selection combo box or whatever ...
		String pelletURI = PelletReasonerFactory.theInstance().getURI();
		
		// insert the PelletReasonerFactory into the registry
		// using the uri
		ReasonerRegistry.theRegistry().register(pelletURI, PelletReasonerFactory.theInstance());
		
		// from here on, every call is unrelated to pellet. Only jena API
		// calls are used. The factory pattern allows the creation of the
		// pellet instance without knowing the pellet peculiarities
		//
		
	    // retrieve the factory via url of the pellet reasoner
		ReasonerFactory factory = ReasonerRegistry.theRegistry().getFactory(pelletURI);
	    
		// create a spec for the model factory
		// specs describe which constructs are allowed,
		// which type of persistence to use (InMemory, DB) 
		// which reasoner and which DocumentManager to use
		OntModelSpec spec = new OntModelSpec(OntModelSpec.OWL_MEM);
		spec.setReasonerFactory(factory);
	    
	    // read ABox, instance information
	    Model abox = FileManager.get().loadModel("file:data/owlDemoData.xml");
	    
	    // read TBox aka schema, concept information
	    Model schema = FileManager.get().loadModel("file:data/owlDemoSchema.xml");
	    
	    // Retrieve reasoner and bind it to the TBox via the bindSchema()
	    // method. The reasoner could perform work on the TBox which could
	    // be reused for several ABoxes which can be changed via the
	    // bind() method. This is implementation dependand ...
	    Reasoner reasoner = spec.getReasoner();
	    // WARNING: bindSchema() creates a new reasoner!
	    spec.setReasoner(reasoner.bindSchema(schema));
	    
	    // createXXX() uses the factory stored inside the spec to create
	    // the reasoner and stores it within the ontModel.
	    // The ABox is bound to the reasoner via its bind() method. The
	    // bind() method is used for ABox data whereas the bindSchema()
	    // method is used for TBox data
	    OntModel ontModel = ModelFactory.createOntologyModel(spec, abox);
	    
	    // validate() checks the current ABox data against the TBox data
	    ValidityReport validity = ontModel.validate();
	    if (validity.isValid()) {
	        System.out.println("OK");
	    } else {
	        System.out.println("Conflicts");
	        for (Iterator i = validity.getReports(); i.hasNext(); ) {
	            System.out.println(" - " + i.next());
	        }
	    }

	    // Perform reasoning, inference
	    //
	    
	    Resource gamingComputer = ontModel.getResource("urn:x-hp:eg/GamingComputer");
	    Resource whiteBox = ontModel.getResource("urn:x-hp:eg/whiteBoxZX");
	    
	    // call to contains() uses the reasoner which is stored somewhere inside
	    // the ontModel
	    if (ontModel.contains(whiteBox, RDF.type, gamingComputer)) {
	        System.out.println("White box recognized as gaming computer");
	    } else {
	        System.out.println("Failed to recognize white box correctly");
	    }
	    
	}
}