Examples of org.mindswap.pellet.utils.Timers

org.mindswap.pellet.utils.Timers
larkparsia.com>
@author Evren Sirin

      System.exit(1);
    }
    
    System.out.println("Running baseline...");
    
    org.mindswap.pellet.utils.Timers timers  = new Timers();
    timers.createTimer("classification");
    
    OWLReasonerFactory reasonerFactory = null;
    switch (selectReasoner){
      case 1: reasonerFactory = new PelletReasonerFactory(); break;
      case 2: reasonerFactory = new FaCTPlusPlusReasonerFactory(); break;
      default: reasonerFactory = new PelletReasonerFactory(); break;
    }
    
    OWLReasoner reasoner = reasonerFactory.createReasoner(manager);
    
    logger.info("Reasoner: "+reasonerFactory.getReasonerName());
    
    /* Load Tbox and all imported ontologies */
    reasoner.loadOntologies(Collections.singleton(tbox)); 
    
    /*  Load Abox into reasoner */
    reasoner.loadOntologies(Collections.singleton(abox));
    
    double time = 0;
    double classificationTime = 0;
    
    /*
    try {
      System.out.println("classify: " + new Benchmark(new TaskClassify(reasoner)));
    } catch (IllegalArgumentException e) {
      e.printStackTrace();
    } catch (IllegalStateException e) {
      e.printStackTrace();
    } catch (Exception e) {
      e.printStackTrace();
    }
    */
    
    /* Classify the ontology if necessary */
    if (!reasoner.isClassified()){
      Timer timerClassify = timers.startTimer( "classification" );
      reasoner.classify();
      timerClassify.stop();
      classificationTime = timerClassify.getTotal();
    }
    
    /* Maps each class to the number of instances (including direct and indirect) */
    HashMap<OWLClass, Integer> counts = new HashMap<OWLClass, Integer>();
    
    /* Maps each class to the number of direct instances */
    HashMap<OWLClass, Integer> directIndividualsCounts = new HashMap<OWLClass, Integer>();
    
    /* Maps each class to the number of indirect instances */
    HashMap<OWLClass, Integer> indirectIndividualsCounts = new HashMap<OWLClass, Integer>();    
    
    int cumulativeNumberOfInstances = 0;
    int cumulativeNumberOfDirectInstances = 0;
    int cumulativeNumberOfIndirectInstances = 0;
    double instanceRetrievalTime = 0;
    
    for (OWLClass cc : classes){
      allIndividuals = new HashSet<OWLIndividual>();
      directIndividuals = new HashSet<OWLIndividual>();
      timers.createTimer("retrieval");
      
      System.out.println(reasoner.getEquivalentClasses(cc).size());
      
      /* retrieve all individuals of the class (direct and indirect individuals) */
      Timer timerRetrieval = timers.startTimer( "retrieval" );
      allIndividuals = reasoner.getIndividuals(cc, false);
      timerRetrieval.stop();
      
      /* update instance retrieval time */
      instanceRetrievalTime += timerRetrieval.getTotal();

View Full Code Here

      double aboxUpdateTime = 0;
      double instanceRetrievalTime = 0;
      double approximationTime = 0;
      int individualCounter = 1;
      
      org.mindswap.pellet.utils.Timers timers  = new Timers();
      timers.createTimer("classification");
      timers.createTimer("approximation");
      
      OWLReasonerFactory reasonerFactory = null;
      switch (selectReasoner){
        case 1: reasonerFactory = new PelletReasonerFactory(); break;
        case 2: reasonerFactory = new FaCTPlusPlusReasonerFactory(); break;
        default: reasonerFactory = new PelletReasonerFactory(); break;
      }      
      
      /* Initialize manager used for loading the Abox */
      OWLOntologyManager manager = null;
      manager = OWLManager.createOWLOntologyManager();


      /* Rewrite Tbox T -> T' based on the current vocabulary subset */
      Timer timerApproximation = timers.startTimer( "approximation" );
      ApproximationResult approximationResult = approximation.getNextTBox();
      timerApproximation.stop();
      
      if (approximationResult != null) {
        System.out.println("Creating Tbox approximation "+runCounter);
        
        OWLOntology abox = null;
        OWLOntology approximatedTbox = null;
        OWLReasoner reasoner = null;
        int newIndividualsToAdd = 0;
        
        /* get the approximated Tbox */
        approximatedTbox = approximationResult.approximatedOntology();
      
        if (approximationResult.isOriginal()){
          /* Last run. Use original Abox to compute the baseline run */
          aboxPhysicalURI = originalAboxURI;
        }
        
        /* Load Abox into the manager */
        abox = manager.loadOntologyFromPhysicalURI(aboxPhysicalURI);
        int aboxIndividualAxiomsCount = abox.getIndividualAxioms().size();
          
        if (measureApproximationTime) {
          /* update time with the time it takes to build the Tbox based on the current vocabulary set */
          approximationTime = timerApproximation.getTotal();
        }
      
        //OWLOntology currentTBox2 = approximationResult.approximatedOntology();
        
        /* Create a new physical URI based on the current run */
        URI tboxPhysicalURI = createNewURI(tmpTboxPhysicalURI, runCounter);
        if (saveApproximatedTbox){
          /* Save approximated Tbox to disk - for debugging purposes only */
          saveOntologyToFile(approximatedTbox, tboxPhysicalURI);
        }      
        
        /* Create the reasoner */
        reasoner = reasonerFactory.createReasoner(manager);
        logger.info("Using reasoner: "+reasonerFactory.getReasonerName());
        
        Set<OWLOntology> ontologiesToLoad = new HashSet<OWLOntology>();
        ontologiesToLoad.add(abox);
        ontologiesToLoad.add(approximatedTbox);
        
        /* Load approximated Tbox into the reasoner */
        //reasoner.loadOntologies(ontologiesToLoad);


        /* Load approximated Tbox into reasoner */
        reasoner.loadOntologies(Collections.singleton(approximatedTbox));
        
        /* Print statistics */
        printStatistics(runCounter, approximation, approximatedTbox, abox, aboxPhysicalURI);
        
        /* Classify ontology if needed */
        double classificationTime = 0;
        
        if ( !(reasoner.isClassified()) ){
          logger.info("Classifying KB...");
          Timer timerClassify = timers.startTimer( "classification" );
          reasoner.classify();
          timerClassify.stop();
          classificationTime = timerClassify.getTotal();
        }
        
        /* Load Abox into reasoner */
        reasoner.loadOntologies(Collections.singleton(abox)); 
          
        /* In each run this variable maps classes to number of instances (direct and indirect) retrieved for that class */
        HashMap<OWLClass, Integer> instancesPerClass = new HashMap<OWLClass, Integer>();
        /* Maps classes to number of direct instances */
        HashMap<OWLClass, Integer> directIndividualsCounts = new HashMap<OWLClass, Integer>();
        /* Maps classes to number of indirect instances */
        HashMap<OWLClass, Integer> indirectIndividualsCounts = new HashMap<OWLClass, Integer>();
        
        /* Total number of direct instances retrieved (among all classes) in the current run */
        int cumulativeDirectInstancesCnt = 0;
        
        /* Total number of indirect instances retrieved (among all classes) in the current run */
        int cumulativeIndirectInstancesCnt = 0;
          
        logger.info("Iterating over "+concepts.size()+" atomic concept names (calculated from original tbox)");
        /* Retrieve Instances from (T', A) */
        for (OWLClass cc : concepts){
          /* In each run this variable contains the instances (direct and indirect) retrieved from a given class */
          Set<OWLIndividual> individuals = new HashSet<OWLIndividual>();  
            
          /* In each run this variable contains the instances (direct) retrieved from a given class */
          Set<OWLIndividual> directIndividuals = new HashSet<OWLIndividual>();
            
          /* get all individuals (direct and indirect) of class cc only if the class is defined in the ontology */
          if (reasoner.isDefined(cc)){
            timers.createTimer("retrieval");
            Timer timerRetrieval = timers.startTimer( "retrieval" );
            individuals = reasoner.getIndividuals(cc, false);
            timerRetrieval.stop();
            
            /* get direct individuals only */
            directIndividuals = reasoner.getIndividuals(cc, true);
            
            /* update instance retrieval time */
            instanceRetrievalTime += timerRetrieval.getTotal();
            
            if (individuals.size() > 0){
              logger.info("");
              logger.info("Instance relations found for class "+cc.getURI()+": "+individuals.size()+" (class's retrieval time:"+timerRetrieval.getTotal()+")");
              for (OWLIndividual owli : individuals){
                logger.info(individualCounter+": "+owli.getURI());
                individualCounter++;
              }          
            }
            
          }else{
            //System.out.println("Undefined Concept in Tbox: "+cc);
            logger.info("Undefined Concept in Tbox: "+cc);
          }
            
          /* save the instance relations that were retrieved for the class */
          classInstances.put(cc, individuals);
          
          /* Update number of instances (including direct and indirect) of the current class */
          instancesPerClass.put(cc, new Integer(individuals.size()));
                  
          /* save number of direct and indirect instances of each class */
          directIndividualsCounts.put(cc, new Integer(directIndividuals.size()));
          indirectIndividualsCounts.put(cc, new Integer(individuals.size()-directIndividuals.size()));
          
          if (isInterruptible){
            List<OWLOntologyChange> changesToMake = new Vector<OWLOntologyChange>();
            /* Add instances retrieved in the current run to the current Abox */
            OWLDataFactory factory = manager.getOWLDataFactory();
            timers.createTimer("aboxupdate");
            Timer timerAboxUpdate = timers.startTimer("aboxupdate");
            for (OWLIndividual ci : individuals){
              changesToMake.add(new AddAxiom(abox, factory.getOWLClassAssertionAxiom(ci, cc)));
            }
            List<OWLOntologyChange> actualChangesMade = manager.applyChanges(changesToMake);
            timerAboxUpdate.stop();

View Full Code Here

    }
    return ontology;
  } 
  
  public ApproximationResult getNextTBox(){
    org.mindswap.pellet.utils.Timers timers  = new Timers();
    timers.createTimer("selection");
    
    /* Selection contains concept names only */  
    Timer timerSelection = timers.startTimer("selection");
    this.selection = this.strategy.getNextSelection();
    timerSelection.stop();
    long selectionTime = timerSelection.getTotal();
    
    if (this.selection == null){
      return null;
    }else {
      //if (this.selection.size() == this.strategy.sizeCompleteVocabulary()){
        /* the approximation is equal to the original tbox */
        //ApproximationResult approximationResult = new ApproximationResult(this.fullTBox, true);
        //approximationResult.setOntologyPhysicalURI(this.fullTboxURI);
        //approximationResult.setSelectionTime(selectionTime);
        //return approximationResult;
      //}
    //}
    
    try {
      logger.info("Computing Approximated Tbox...");
      timers.createTimer("rewrite");
      
      OWLOntologyManager manager = null;
      manager = OWLManager.createOWLOntologyManager();
      OWLDataFactory factory = manager.getOWLDataFactory();
      
      /* create the logical and physical URI of the new Tbox */
      //String tmpURI = createTboxURI(this.tmpOntologyURI);
      URI newTboxLogicalURI = URI.create(createTboxURI(this.tmpOntologyURI)); 
      //URI newTboxPhysicalURI = URI.create(tmpURI);
      
      /* Create the temporal TBox that will contain the selection made out of the original (full) TBox */
      OWLOntology approximatedTbox = manager.createOntology(newTboxLogicalURI);
      
      /* Get all the axioms of the original Tbox */
      Set<OWLLogicalAxiom> axioms = this.fullTBox.getLogicalAxioms();
      
      /* Iterate over all logical axioms and rewrite them if necessary. Add each (possibly rewritten) axiom to 
       * the approximated Tbix */
      //long axiomRewritingTimeStart = System.nanoTime();
      Timer timerRewrite = timers.startTimer("rewrite");
      for (OWLLogicalAxiom ca : axioms){
        //logger.info("Axiom: "+ca.toString());
        if (!(ca instanceof OWLClassAssertionAxiom) && !(ca instanceof OWLIndividualAxiom)){
          if (ca instanceof OWLSubClassAxiom){
            //logger.info("");

View Full Code Here

            + owlProperty.getURI());
        pCounter++;
      }
      logger.info("");


      org.mindswap.pellet.utils.Timers timers = new Timers();
      
      timers.createTimer("classification");


      /* Create the reaosner */
      OWLReasoner reasoner = reasonerFactory.createReasoner(manager);


      System.out
          .println("Classifying and retrieving instance relations...");
      this.logger
          .info("Classifying and retrieving instance relations...");
      this.logger.info("Using reasoner: "
          + reasonerFactory.getReasonerName());


      /* Load Tbox into reasoner */
      reasoner.loadOntologies(Collections.singleton(tbox));


      /* Load Abox into reasoner */
      // reasoner.loadOntologies(Collections.singleton(abox));
      /* Classify the ontology if necessary */
      if (!reasoner.isClassified())
      {
        /* Measure time using Benchmarking framework */
        Timer timerClassify = timers.startTimer("classification");
        reasoner.classify();
        timerClassify.stop();
        classificationTime = timerClassify.getTotal();
      }


      /* Load Abox into reasoner */
      reasoner.loadOntologies(Collections.singleton(abox));
      if (!reasoner.isClassified())
      {
        reasoner.classify();
      }


      /*
       * Maps each class to the number of instances (including direct and
       * indirect)
       */
      HashMap<OWLClass, Integer> allIndividualsCounts = new HashMap<OWLClass, Integer>();


      /* Maps each class to the number of direct instances */
      HashMap<OWLClass, Integer> directIndividualsCounts = new HashMap<OWLClass, Integer>();


      /* Maps each class to the number of indirect instances */
      HashMap<OWLClass, Integer> indirectIndividualsCounts = new HashMap<OWLClass, Integer>();


      int individualCounter = 1;


      for (OWLClass cc : classes)
      {
        allIndividuals = new HashSet<OWLIndividual>();
        directIndividuals = new HashSet<OWLIndividual>();


        if (reasoner.isDefined(cc))
        {
          /*
           * retrieve all individuals of the class (direct and
           * indirect individuals)
           */
          timers.createTimer("retrieval");
          Timer timerRetrieval = timers.startTimer("retrieval");
          allIndividuals = reasoner.getIndividuals(cc, false);
          timerRetrieval.stop();


          /* update instance retrieval time */
          instanceRetrievalTime += timerRetrieval.getTotal();

View Full Code Here

      HashMap<OWLClass, Integer> indirectIndividualsCounts = new HashMap<OWLClass, Integer>();


      int cumulativeDirectIndividualsCounts = 0;
      int cumulativeIndirectIndividualsCounts = 0;


      Timers timers = new Timers();


      double classificationTime = 0;
      double approximationTime = 0;
      double instanceRetrievalTime = 0;
      double aboxUpdateTime = 0;
      double time = 0;


      // System.out.println("--->approximating...");
      timers.createTimer("approximation");
      Timer timerApproximation = timers.startTimer("approximation");
      approximationResult = approximation.getNextTBox();
      timerApproximation.stop();
      if (measureApproximationTime)
      {
        approximationTime += timerApproximation.getTotal();
      }


      if (approximationResult != null)
      {
        approximatedTboxOntology = approximationResult
            .approximatedOntology();


        URI tboxPhysicalURI = createURI(tmpTboxPhysicalURI, runCounter);
        if (saveApproximatedTbox)
        {
          saveOntology(approximatedTboxOntology, tboxPhysicalURI);
        }


        // System.out.println("--->classifying...");
        reasoner = reasonerFactory.createReasoner(manager);
        reasoner.loadOntologies(Collections
            .singleton(approximatedTboxOntology));
        timers.createTimer("classification");
        if (!(reasoner.isClassified()))
        {
          Timer timerClassify = timers.startTimer("classification");
          reasoner.classify();
          timerClassify.stop();
          classificationTime += timerClassify.getTotal();
        }


        if (approximationResult.isOriginal())
        {
          aboxPhysicalURI = originalAboxPhysicalURI;
        }


        aboxOntology = manager
            .loadOntologyFromPhysicalURI(aboxPhysicalURI);


        reasoner.loadOntologies(Collections.singleton(aboxOntology));


        // System.out.println("--->retrieving instances...");
        for (OWLClass cc : concepts)
        {
          Set<OWLIndividual> individuals = new HashSet<OWLIndividual>();
          Set<OWLIndividual> directIndividuals = new HashSet<OWLIndividual>();


          if (reasoner.isDefined(cc))
          {
            timers.createTimer("retrieval");
            Timer timerRetrieval = timers.startTimer("retrieval");
            individuals = reasoner.getIndividuals(cc, false);
            timerRetrieval.stop();
            instanceRetrievalTime += timerRetrieval.getTotal();
          }


          directIndividuals = reasoner.getIndividuals(cc, true);
          allIndividualsCounts.put(cc,
              new Integer(individuals.size()));
          directIndividualsCounts.put(cc, new Integer(
              directIndividuals.size()));
          indirectIndividualsCounts.put(cc, new Integer(individuals
              .size()
              - directIndividuals.size()));


          if (isInterruptible)
          {


            List<OWLOntologyChange> changesToMake = new Vector<OWLOntologyChange>();
            OWLDataFactory factory = manager.getOWLDataFactory();
            timers.createTimer("aboxupdate");
            Timer timerAboxUpdate = timers.startTimer("aboxupdate");
            for (OWLIndividual ci : individuals)
            {
              changesToMake.add(new AddAxiom(aboxOntology,
                  factory.getOWLClassAssertionAxiom(ci, cc)));
            }

View Full Code Here


    int cumulativeIndividualsCount = 0;
    int cumulativeDirectindividualsCount = 0;
    int cumulativeIndirectIndividualsCount = 0;


    Timers timers = new Timers();
    double time = 0;
    double classificationTime = 0;
    double instanceRetrievalTime = 0;


    try
    {
      tboxOntology = manager.loadOntology(tboxURI);
      aboxOntology = manager.loadOntology(aboxURI);


    } catch (OWLOntologyCreationException e)
    {
      e.printStackTrace();
      System.exit(0);
    }


    // System.out.println("--->classifying...");
    reasoner = reasonerFactory.createReasoner(manager);
    reasoner.loadOntologies(Collections.singleton(tboxOntology));
    reasoner.loadOntologies(Collections.singleton(aboxOntology));
    timers.createTimer("classification");


    if (!reasoner.isClassified())
    {
      Timer timerClassify = timers.startTimer("classification");
      reasoner.classify();
      timerClassify.stop();
      classificationTime += timerClassify.getTotal();
    }
    // System.out.println("--->retrieving instances...");
    for (OWLClass cc : classes)
    {
      allIndividuals = new HashSet<OWLIndividual>();
      directIndividuals = new HashSet<OWLIndividual>();
      timers.createTimer("retrieval");
      Timer timerRetrieval = timers.startTimer("retrieval");
      allIndividuals = reasoner.getIndividuals(cc, false);
      timerRetrieval.stop();
      instanceRetrievalTime += timerRetrieval.getTotal();


      fullCassIndividuals.put(cc, allIndividuals);

View Full Code Here

    
    // Get an instance of the incremental classifier
    IncrementalClassifier classifier = new IncrementalClassifier( ontologyTBox );


    // We need some timing to show the performance of the classification
    Timers timers = new Timers();


    // We classify the ontology and use a specific timer to keep track of
    // the time required for the classification
    Timer t = timers.createTimer( "First classification" );
    t.start();
    classifier.classify();
    t.stop();
        
    System.out.println( "\nClassification time: " + t.getTotal() + "ms");
    System.out.println( "Subclasses of " + pain + ": " + classifier.getSubClasses( pain, true ).getFlattened() + "\n");
    
    // Now create a new OWL axiom, subClassOf(Headache, Pain)
    OWLAxiom axiom = OWL.subClassOf( headache, pain );


    // Add the axiom to the ontology, which creates a change event
    OWL.manager.applyChange( new AddAxiom( ontologyTBox, axiom ) );


    // Now we create a second timer to keep track of the performance of the
    // second classification
    t = timers.createTimer("Second classification");
    t.start();
    classifier.classify();
    t.stop();
    
    System.out.println( "\nClassification time: " + t.getTotal() + "ms");
    System.out.println( "Subclasses of " + pain + ": " + classifier.getSubClasses( pain, true ).getFlattened() + "\n");


    // Remove the axiom from the ontology, which creates a change event
    OWL.manager.applyChange( new RemoveAxiom( ontologyTBox, axiom ) );


    // Now we create a third timer to keep track of the performance of the
    // third classification
    timers.startTimer( "Third classification" );
    classifier.classify();
    timers.stopTimer( "Third classification" );
    
    System.out.println( "\nClassification time: " + t.getTotal() + "ms");
    System.out.println( "Subclasses of " + pain + ": " + classifier.getSubClasses( pain, true ).getFlattened() + "\n");
    
    // Finally, print the timing. As you can see, the second classification
    // takes significantly less time, which is the characteristic of the
    // incremental classifier.
    System.out.println( "Timers summary" );
    for( Timer timer : timers.getTimers() ) {
      if( !timer.isStarted() )
        System.out.println( timer.getName() + ": " + timer.getTotal() + "ms" );
    }
    
  }

View Full Code Here

    
    // Get an instance of the incremental classifier
    IncrementalClassifier classifier = new IncrementalClassifier( ontology );


    // We need some timing to show the performance of the classification
    Timers timers = new Timers();


    // We classify the ontology and use a specific timer to keep track of
    // the time required for the classification
    Timer t = timers.createTimer( "First classification" );
    t.start();
    classifier.classify();
    t.stop();
        
    System.out.println( "\nClassification time: " + t.getTotal() + "ms"); 
    System.out.println( "Subclasses of " + pain + ": " + classifier.getSubClasses( pain, true ).getFlattened() + "\n");
    
    // Now create a new OWL axiom, subClassOf(Headache, Pain)
    OWLAxiom axiom = OWL.subClassOf( headache, pain );


    // Add the axiom to the ontology, which creates a change event
    OWL.manager.applyChange( new AddAxiom( ontology, axiom ) );


    // Now we create a second timer to keep track of the performance of the
    // second classification
    t = timers.createTimer( "Second classification" );
    t.start();
    classifier.classify();
    t.stop();
    
    System.out.println( "\nClassification time: " + t.getTotal() + "ms");
    System.out.println( "Subclasses of " + pain + ": " + classifier.getSubClasses( pain, true ).getFlattened() + "\n");


    // Remove the axiom from the ontology, which creates a change event
    OWL.manager.applyChange( new RemoveAxiom( ontology, axiom ) );


    // Now we create a third timer to keep track of the performance of the
    // third classification
    timers.startTimer( "Third classification" );
    classifier.classify();
    timers.stopTimer( "Third classification" );
    
    System.out.println( "\nClassification time: " + t.getTotal() + "ms");
    System.out.println( "Subclasses of " + pain + ": " + classifier.getSubClasses( pain, true ).getFlattened() + "\n");
    
    // Finally, print the timing. As you can see, the second classification
    // takes significantly less time, which is the characteristic of the
    // incremental classifier.
    System.out.println( "Timers summary" );
    for( Timer timer : timers.getTimers() ) {
      if( !timer.isStarted() )
        System.out.println( timer.getName() + ": " + timer.getTotal() + "ms" );
    }
  }

View Full Code Here

  public PelletCmdApp() {
    this.options = getOptions();
    this.appId = getAppId();
    this.appCmd = getAppCmd();
    this.inputFiles = new ArrayList<String>();
    this.timers = new Timers();


    buildHelp();
  }

View Full Code Here

  public PelletCmdApp() {
    this.options = getOptions();
    this.appId = getAppId();
    this.appCmd = getAppCmd();
    this.inputFiles = new ArrayList<String>();
    this.timers = new Timers();


    buildHelp();
  }

View Full Code Here

TOP

Related Classes of org.mindswap.pellet.utils.Timers

nl.vu.few.anytimereasoning.workbench.approximation.ApproximationManager

nl.vu.few.anytimereasoning.workbench.approximation.ApproximationTask

nl.vu.few.anytimereasoning.workbench.reasoningtask.InstanceRetrieval

org.ar.redoexperiments.ExperimentManager

org.mindswap.pellet.examples.IncrementalClassifierExample

org.mindswap.pellet.output.TableData

pellet.PelletCmdApp

java.text.NumberFormat

java.text.DecimalFormat

java.io.PrintWriter

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.