예제 #1
0
 private void classifyWithJFact(OWLOntology ontology) {
   System.out.println("\nUsing JFact ...");
   long startTime = System.nanoTime();
   OWLReasonerFactory reasonerFactory = new JFactFactory();
   OWLReasoner jfactReasoner = reasonerFactory.createReasoner(ontology);
   jfactReasoner.precomputeInferences(InferenceType.CLASS_HIERARCHY);
   jfactReasoner.dispose();
   System.out.println("Time taken (secs): " + Util.getElapsedTimeSecs(startTime));
 }
예제 #2
0
 @SuppressWarnings({"unchecked", "rawtypes"})
 private OWLReasoner createModuleReasoner() throws OWLOntologyCreationException {
   LOG.info("Creating module reasoner for module: " + modelId);
   ModuleType mtype = ModuleType.BOT;
   OWLOntologyManager m =
       OWLManager.createOWLOntologyManager(
           aboxOntology.getOWLOntologyManager().getOWLDataFactory());
   SyntacticLocalityModuleExtractor sme =
       new SyntacticLocalityModuleExtractor(m, aboxOntology, mtype);
   Set<OWLEntity> seeds = (Set) aboxOntology.getIndividualsInSignature();
   OWLOntology module = sme.extractAsOntology(seeds, IRI.generateDocumentIRI());
   OWLReasoner reasoner = reasonerFactory.createReasoner(module);
   LOG.info("Done creating module reasoner module: " + modelId);
   return reasoner;
 }
예제 #3
0
 /** @return current reasoner, operating over abox */
 public OWLReasoner getReasoner() {
   synchronized (reasonerMutex) {
     if (reasoner == null) {
       // reasoner -> query -> abox -> tbox
       if (LOG.isDebugEnabled()) {
         LOG.debug(
             "Creating reasoner on "
                 + queryOntology
                 + " ImportsClosure="
                 + queryOntology.getImportsClosure());
       }
       reasoner = reasonerFactory.createReasoner(queryOntology);
     }
   }
   return reasoner;
 }
예제 #4
0
  public void getELKIncrementalRuntime(String baseOnt, String ontDir) throws Exception {
    GregorianCalendar start = new GregorianCalendar();
    OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
    IRI documentIRI = IRI.create(new File(baseOnt));
    OWLOntology baseOntology = manager.loadOntology(documentIRI);
    System.out.println("Logical axioms: " + baseOntology.getLogicalAxiomCount());
    //		findDataHasValueAxiom(baseOntology.getAxioms(AxiomType.SUBCLASS_OF));

    OWLReasonerFactory reasonerFactory = new ElkReasonerFactory();
    OWLReasoner reasoner = reasonerFactory.createReasoner(baseOntology);
    reasoner.precomputeInferences(InferenceType.CLASS_HIERARCHY);
    File[] files = new File(ontDir).listFiles();
    int count = 0;
    OWLOntologyManager manager2 = OWLManager.createOWLOntologyManager();
    addTripsBaseOntologies(manager2);
    for (File file : files) {
      System.out.println("File name: " + file.getName());
      documentIRI = IRI.create(file);
      OWLOntology ontology = manager2.loadOntology(documentIRI);
      Set<OWLLogicalAxiom> axioms = ontology.getLogicalAxioms();
      //	    	findDataHasValueAxiom(ontology.getAxioms(AxiomType.SUBCLASS_OF));
      manager.addAxioms(baseOntology, axioms);
      reasoner.flush();
      System.out.println("Logical axioms: " + baseOntology.getLogicalAxiomCount());

      // From the ELK wiki, it seems ABox reasoning will trigger TBox reasoning
      reasoner.precomputeInferences(InferenceType.CLASS_ASSERTIONS);

      manager2.removeOntology(ontology);
      count++;
      System.out.println("Done with " + count);
      //	    	if(count == 5)
      //	    		break;
    }
    reasoner.dispose();
    System.out.println("Time taken (millis): " + Util.getElapsedTime(start));
  }
예제 #5
0
  public static void main(String[] args) {

    try {
      // Create our ontology manager in the usual way.
      OWLOntologyManager manager = OWLManager.createOWLOntologyManager();

      // Load a copy of the people+pets ontology.  We'll load the ontology from the web (it's
      // acutally located
      // in the TONES ontology repository).
      IRI docIRI = IRI.create(DOCUMENT_IRI);
      // We load the ontology from a document - our IRI points to it directly
      OWLOntology ont = manager.loadOntologyFromOntologyDocument(docIRI);
      System.out.println("Loaded " + ont.getOntologyID());

      // We need to create an instance of OWLReasoner.  An OWLReasoner provides the basic
      // query functionality that we need, for example the ability obtain the subclasses
      // of a class etc.  To do this we use a reasoner factory.

      // Create a reasoner factory.  In this case, we will use HermiT, but we could also
      // use FaCT++ (http://code.google.com/p/factplusplus/) or
      // Pellet(http://clarkparsia.com/pellet)
      // Note that (as of 03 Feb 2010) FaCT++ and Pellet OWL API 3.0.0 compatible libraries are
      // expected to be available in the near future).

      // For now, we'll use HermiT
      // HermiT can be downloaded from http://hermit-reasoner.com
      // Make sure you get the HermiT library and add it to your class path.  You can then
      // instantiate the HermiT reasoner factory:
      // Comment out the first line below and uncomment the second line below to instantiate
      // the HermiT reasoner factory.  You'll also need to import the
      // org.semanticweb.HermiT.Reasoner
      // package.
      OWLReasonerFactory reasonerFactory = null;
      //            OWLReasonerFactory reasonerFactory = new Reasoner.ReasonerFactory();

      // We'll now create an instance of an OWLReasoner (the implementation being provided by HermiT
      // as
      // we're using the HermiT reasoner factory).  The are two categories of reasoner, Buffering
      // and
      // NonBuffering.  In our case, we'll create the buffering reasoner, which is the default kind
      // of reasoner.
      // We'll also attach a progress monitor to the reasoner.  To do this we set up a configuration
      // that
      // knows about a progress monitor.

      // Create a console progress monitor.  This will print the reasoner progress out to the
      // console.
      ConsoleProgressMonitor progressMonitor = new ConsoleProgressMonitor();
      // Specify the progress monitor via a configuration.  We could also specify other setup
      // parameters in
      // the configuration, and different reasoners may accept their own defined parameters this
      // way.
      OWLReasonerConfiguration config = new SimpleConfiguration(progressMonitor);
      // Create a reasoner that will reason over our ontology and its imports closure.  Pass in the
      // configuration.
      OWLReasoner reasoner = reasonerFactory.createReasoner(ont, config);

      // Ask the reasoner to do all the necessary work now
      reasoner.precomputeInferences();

      // We can determine if the ontology is actually consistent (in this case, it should be).
      boolean consistent = reasoner.isConsistent();
      System.out.println("Consistent: " + consistent);
      System.out.println("\n");

      // We can easily get a list of unsatisfiable classes.  (A class is unsatisfiable if it
      // can't possibly have any instances).  Note that the getUnsatisfiableClasses method
      // is really just a convenience method for obtaining the classes that are equivalent
      // to owl:Nothing.  In our case there should be just one unsatisfiable class - "mad_cow"
      // We ask the reasoner for the unsatisfiable classes, which returns the bottom node
      // in the class hierarchy (an unsatisfiable class is a subclass of every class).
      Node<OWLClass> bottomNode = reasoner.getUnsatisfiableClasses();
      // This node contains owl:Nothing and all the classes that are equivalent to owl:Nothing -
      // i.e. the unsatisfiable classes.
      // We just want to print out the unsatisfiable classes excluding owl:Nothing, and we can
      // used a convenience method on the node to get these
      Set<OWLClass> unsatisfiable = bottomNode.getEntitiesMinusBottom();
      if (!unsatisfiable.isEmpty()) {
        System.out.println("The following classes are unsatisfiable: ");
        for (OWLClass cls : unsatisfiable) {
          System.out.println("    " + cls);
        }
      } else {
        System.out.println("There are no unsatisfiable classes");
      }
      System.out.println("\n");

      // Now we want to query the reasoner for all descendants of vegetarian.  Vegetarians are
      // defined in the
      // ontology to be animals that don't eat animals or parts of animals.
      OWLDataFactory fac = manager.getOWLDataFactory();
      // Get a reference to the vegetarian class so that we can as the reasoner about it.
      // The full IRI of this class happens to be:
      // <http://owl.man.ac.uk/2005/07/sssw/people#vegetarian>
      OWLClass vegPizza =
          fac.getOWLClass(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#vegetarian"));

      // Now use the reasoner to obtain the subclasses of vegetarian.
      // We can ask for the direct subclasses of vegetarian or all of the (proper) subclasses of
      // vegetarian.
      // In this case we just want the direct ones (which we specify by the "true" flag).
      NodeSet<OWLClass> subClses = reasoner.getSubClasses(vegPizza, true);

      // The reasoner returns a NodeSet, which represents a set of Nodes.
      // Each node in the set represents a subclass of vegetarian pizza.  A node of classes contains
      // classes,
      // where each class in the node is equivalent. For example, if we asked for the
      // subclasses of some class A and got back a NodeSet containing two nodes {B, C} and {D}, then
      // A would have
      // two proper subclasses.  One of these subclasses would be equivalent to the class D, and the
      // other would
      // be the class that is equivalent to class B and class C.

      // In this case, we don't particularly care about the equivalences, so we will flatten this
      // set of sets and print the result
      Set<OWLClass> clses = subClses.getFlattened();
      System.out.println("Subclasses of vegetarian: ");
      for (OWLClass cls : clses) {
        System.out.println("    " + cls);
      }
      System.out.println("\n");

      // In this case, we should find that the classes, cow, sheep and giraffe are vegetarian.  Note
      // that in this
      // ontology only the class cow had been stated to be a subclass of vegetarian.  The fact that
      // sheep and
      // giraffe are subclasses of vegetarian was implicit in the ontology (through other things we
      // had said)
      // and this illustrates why it is important to use a reasoner for querying an ontology.

      // We can easily retrieve the instances of a class.  In this example we'll obtain the
      // instances of
      // the class pet.  This class has a full IRI of <http://owl.man.ac.uk/2005/07/sssw/people#pet>

      // We need to obtain a reference to this class so that we can ask the reasoner about it.
      OWLClass country =
          fac.getOWLClass(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#pet"));
      // Ask the reasoner for the instances of pet
      NodeSet<OWLNamedIndividual> individualsNodeSet = reasoner.getInstances(country, true);
      // The reasoner returns a NodeSet again.  This time the NodeSet contains individuals.
      // Again, we just want the individuals, so get a flattened set.
      Set<OWLNamedIndividual> individuals = individualsNodeSet.getFlattened();
      System.out.println("Instances of pet: ");
      for (OWLNamedIndividual ind : individuals) {
        System.out.println("    " + ind);
      }
      System.out.println("\n");

      // Again, it's worth noting that not all of the individuals that are returned were explicitly
      // stated
      // to be pets.

      // Finally, we can ask for the property values (property assertions in OWL speak) for a given
      // individual
      // and property.
      // Let's get the property values for the individual Mick, the full IRI of which is
      // <http://owl.man.ac.uk/2005/07/sssw/people#Mick>

      // Get a reference to the individual Mick
      OWLNamedIndividual mick =
          fac.getOWLNamedIndividual(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#Mick"));

      // Let's get the pets of Mick
      // Get hold of the has_pet property which has a full IRI of
      // <http://owl.man.ac.uk/2005/07/sssw/people#has_pet>
      OWLObjectProperty hasPet =
          fac.getOWLObjectProperty(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#has_pet"));

      // Now ask the reasoner for the has_pet property values for Mick
      NodeSet<OWLNamedIndividual> petValuesNodeSet = reasoner.getObjectPropertyValues(mick, hasPet);
      Set<OWLNamedIndividual> values = petValuesNodeSet.getFlattened();
      System.out.println("The has_pet property values for Mick are: ");
      for (OWLNamedIndividual ind : values) {
        System.out.println("    " + ind);
      }

      // Notice that Mick has a pet Rex, which wasn't asserted in the ontology.

      // Finally, let's print out the class hierarchy.
      // Get hold of the top node in the class hierarchy (containing owl:Thing)
      // Now print the hierarchy out
      Node<OWLClass> topNode = reasoner.getTopClassNode();
      print(topNode, reasoner, 0);

    } catch (UnsupportedOperationException exception) {
      System.out.println("Unsupported reasoner operation.");
    } catch (OWLOntologyCreationException e) {
      System.out.println("Could not load the pizza ontology: " + e.getMessage());
    }
  }
예제 #6
0
  private void precomputeAndCheckResults(OWLOntology ontology) throws Exception {
    System.out.println("Not Normalizing");

    PropertyFileHandler propertyFileHandler = PropertyFileHandler.getInstance();
    HostInfo resultNodeHostInfo = propertyFileHandler.getResultNode();
    // port: 6489 for snapshot testing
    Jedis resultStore =
        new Jedis(
            resultNodeHostInfo.getHost(), resultNodeHostInfo.getPort(), Constants.INFINITE_TIMEOUT);
    Jedis resultStore2 =
        new Jedis(
            resultNodeHostInfo.getHost(), resultNodeHostInfo.getPort(), Constants.INFINITE_TIMEOUT);
    resultStore2.select(2);
    HostInfo localHostInfo = propertyFileHandler.getLocalHostInfo();
    Jedis localStore = new Jedis(localHostInfo.getHost(), localHostInfo.getPort());
    Set<String> idHosts =
        localStore.zrange(
            AxiomDistributionType.CONCEPT_ID.toString(),
            Constants.RANGE_BEGIN,
            Constants.RANGE_END);
    // currently there is only one ID node
    String[] idHostPort = idHosts.iterator().next().split(":");
    Jedis idReader =
        new Jedis(idHostPort[0], Integer.parseInt(idHostPort[1]), Constants.INFINITE_TIMEOUT);
    GregorianCalendar cal1 = new GregorianCalendar();
    try {
      //		    OWLReasonerFactory reasonerFactory = new ElkReasonerFactory();
      //		    OWLReasoner reasoner = reasonerFactory.createReasoner(ontology);
      //		    reasoner.precomputeInferences(InferenceType.CLASS_HIERARCHY);
      //		    PelletReasoner reasoner = PelletReasonerFactory.getInstance().
      //		    									createReasoner( ontology );
      //		    reasoner.prepareReasoner();

      //	    Reasoner hermitReasoner = new Reasoner(ontology);
      //	    hermitReasoner.precomputeInferences(InferenceType.CLASS_HIERARCHY);

      //	    	OWLReasonerFactory reasonerFactory = new ElkReasonerFactory();
      //		    OWLReasoner reasoner = reasonerFactory.createReasoner(ontology);
      //		    reasoner.precomputeInferences(InferenceType.CLASS_HIERARCHY);

      //		    RELReasonerFactory relfactory = new RELReasonerFactory();
      //		    RELReasoner reasoner = relfactory.createReasoner(ontology);
      //		    reasoner.precomputeInferences(InferenceType.CLASS_HIERARCHY);

      //	    	JcelReasoner reasoner = new JcelReasoner(ontology, false);
      //		    reasoner.precomputeInferences(InferenceType.CLASS_HIERARCHY);

      OWLReasonerFactory reasonerFactory = new ElkReasonerFactory();
      OWLReasoner reasoner = reasonerFactory.createReasoner(ontology);
      reasoner.precomputeInferences(InferenceType.CLASS_HIERARCHY);

      System.out.println("Reasoner completed in (millis): " + Util.getElapsedTime(cal1));

      System.out.println("Comparing results using ELK.....");
      rearrangeAndCompareResults(ontology, reasoner, resultStore, resultStore2, idReader);

      //		    pelletReasoner.dispose();
      //	   		reasonerELK.dispose();
      reasoner.dispose();
    } finally {
      localStore.disconnect();
      resultStore.disconnect();
      resultStore2.disconnect();
      idReader.disconnect();
    }
  }