Menu
▾
▴
[DL-Learner SVN] SF.net SVN: dl-learner:[1574] trunk
|
From: <jen...@us...> - 2009-01-11 12:32:23
|
Revision: 1574
http://dl-learner.svn.sourceforge.net/dl-learner/?rev=1574&view=rev
Author: jenslehmann
Date: 2009-01-11 11:53:29 +0000 (Sun, 11 Jan 2009)
Log Message:
-----------
several changes to improve EL operator performance
Modified Paths:
--------------
trunk/doc/checkstyle.xml
trunk/src/dl-learner/org/dllearner/algorithms/el/ELDescriptionTree.java
trunk/src/dl-learner/org/dllearner/algorithms/el/ELLearningAlgorithm.java
trunk/src/dl-learner/org/dllearner/examples/corpus/Sentence.java
trunk/src/dl-learner/org/dllearner/refinementoperators/ELDown2.java
trunk/src/dl-learner/org/dllearner/refinementoperators/Utility.java
trunk/src/dl-learner/org/dllearner/scripts/evaluation/ELOperatorBenchmark.java
trunk/src/dl-learner/org/dllearner/test/junit/ELDownTests.java
Modified: trunk/doc/checkstyle.xml
===================================================================
--- trunk/doc/checkstyle.xml 2009-01-11 07:56:41 UTC (rev 1573)
+++ trunk/doc/checkstyle.xml 2009-01-11 11:53:29 UTC (rev 1574)
@@ -82,7 +82,7 @@
</module>
<module name="UpperEll"/>
<module name="Header">
- <property name="header" value="/** * Copyright (C) 2007-2008, Jens Lehmann * * This file is part of DL-Learner. * * DL-Learner is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * DL-Learner is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. * */"/>
+ <property name="header" value="/** * Copyright (C) 2007-2009, Jens Lehmann * * This file is part of DL-Learner. * * DL-Learner is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * DL-Learner is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. * */"/>
<property name="ignoreLines" value="20"/>
</module>
</module>
Modified: trunk/src/dl-learner/org/dllearner/algorithms/el/ELDescriptionTree.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/algorithms/el/ELDescriptionTree.java 2009-01-11 07:56:41 UTC (rev 1573)
+++ trunk/src/dl-learner/org/dllearner/algorithms/el/ELDescriptionTree.java 2009-01-11 11:53:29 UTC (rev 1574)
@@ -19,6 +19,7 @@
*/
package org.dllearner.algorithms.el;
+import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
@@ -31,17 +32,15 @@
import org.apache.log4j.Logger;
import org.dllearner.core.ReasonerComponent;
+import org.dllearner.core.owl.ClassHierarchy;
import org.dllearner.core.owl.Description;
import org.dllearner.core.owl.Intersection;
import org.dllearner.core.owl.NamedClass;
import org.dllearner.core.owl.ObjectProperty;
import org.dllearner.core.owl.ObjectPropertyHierarchy;
import org.dllearner.core.owl.ObjectSomeRestriction;
-import org.dllearner.core.owl.ClassHierarchy;
import org.dllearner.core.owl.Thing;
import org.dllearner.core.owl.UnsupportedLanguageException;
-import org.dllearner.refinementoperators.ELDown2;
-import org.dllearner.utilities.Helper;
import com.jamonapi.Monitor;
import com.jamonapi.MonitorFactory;
@@ -56,6 +55,7 @@
*/
public class ELDescriptionTree implements Cloneable {
+ @SuppressWarnings("unused")
private static Logger logger = Logger.getLogger(ELDescriptionTree.class);
// to simplify equivalence checks and minimisation, we
@@ -69,7 +69,7 @@
protected ELDescriptionNode rootNode;
// the set of all nodes in the tree
- private Set<ELDescriptionNode> nodes = new HashSet<ELDescriptionNode>();
+ private Collection<ELDescriptionNode> nodes = new LinkedList<ELDescriptionNode>();
// nodes on a given level of the tree
private Map<Integer, Set<ELDescriptionNode>> levelNodeMapping = new HashMap<Integer, Set<ELDescriptionNode>>();
@@ -535,7 +535,7 @@
treeClone.maxLevel = maxLevel;
// nodes
- treeClone.nodes = new HashSet<ELDescriptionNode>();
+ treeClone.nodes = new LinkedList<ELDescriptionNode>();
for(ELDescriptionNode oldNode : nodes) {
treeClone.nodes.add(cloneMap.get(oldNode));
}
@@ -591,7 +591,7 @@
/**
* @return the nodes
*/
- public Set<ELDescriptionNode> getNodes() {
+ public Collection<ELDescriptionNode> getNodes() {
return nodes;
}
Modified: trunk/src/dl-learner/org/dllearner/algorithms/el/ELLearningAlgorithm.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/algorithms/el/ELLearningAlgorithm.java 2009-01-11 07:56:41 UTC (rev 1573)
+++ trunk/src/dl-learner/org/dllearner/algorithms/el/ELLearningAlgorithm.java 2009-01-11 11:53:29 UTC (rev 1574)
@@ -22,7 +22,6 @@
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
-import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
@@ -116,7 +115,7 @@
// pick the best candidate according to the heuristic
SearchTreeNode best = candidates.pollLast();
// apply operator
- Set<ELDescriptionTree> refinements = operator.refine(best.getDescriptionTree());
+ List<ELDescriptionTree> refinements = operator.refine(best.getDescriptionTree());
// add all refinements to search tree, candidates, best descriptions
for(ELDescriptionTree refinement : refinements) {
addDescriptionTree(refinement, best);
Modified: trunk/src/dl-learner/org/dllearner/examples/corpus/Sentence.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/examples/corpus/Sentence.java 2009-01-11 07:56:41 UTC (rev 1573)
+++ trunk/src/dl-learner/org/dllearner/examples/corpus/Sentence.java 2009-01-11 11:53:29 UTC (rev 1574)
@@ -8,10 +8,8 @@
import org.dllearner.examples.Corpus;
import org.dllearner.utilities.URLencodeUTF8;
import org.semanticweb.owl.model.OWLClass;
-import org.semanticweb.owl.model.OWLClassAssertionAxiom;
import org.semanticweb.owl.model.OWLDescription;
import org.semanticweb.owl.model.OWLIndividual;
-import org.semanticweb.owl.model.OWLObject;
import org.semanticweb.owl.model.OWLObjectProperty;
public class Sentence {
@@ -72,11 +70,11 @@
//%String %% word lemma tag morph edge parent secedge comment
String word = st.nextToken();
- String lemma = st.nextToken();
+// String lemma = st.nextToken();
String tag = st.nextToken();
String morph = st.nextToken();
String edge = st.nextToken();
- String parent = st.nextToken();
+// String parent = st.nextToken();
//word
if(word.startsWith("#")){
elementURL+="s_"+id+"_"+word.substring(1);
Modified: trunk/src/dl-learner/org/dllearner/refinementoperators/ELDown2.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/refinementoperators/ELDown2.java 2009-01-11 07:56:41 UTC (rev 1573)
+++ trunk/src/dl-learner/org/dllearner/refinementoperators/ELDown2.java 2009-01-11 11:53:29 UTC (rev 1574)
@@ -95,7 +95,6 @@
public ELDown2(ReasonerComponent rs) {
this.rs = rs;
- utility = new Utility(rs);
subsumptionHierarchy = rs.getClassHierarchy();
opHierarchy = rs.getObjectPropertyHierarchy();
@@ -104,7 +103,9 @@
for(ObjectProperty op : rs.getObjectProperties()) {
opDomains.put(op, rs.getDomain(op));
opRanges.put(op, rs.getRange(op));
- }
+ }
+
+ utility = new Utility(rs, opDomains);
}
/* (non-Javadoc)
@@ -114,7 +115,7 @@
public Set<Description> refine(Description concept) {
logger.trace("refining " + concept);
ELDescriptionTree tree = new ELDescriptionTree(rs, concept);
- Set<ELDescriptionTree> refinementTrees = refine(tree);
+ List<ELDescriptionTree> refinementTrees = refine(tree);
Set<Description> refinements = new HashSet<Description>();
for(ELDescriptionTree refinementTree : refinementTrees) {
refinements.add(refinementTree.transformToDescription());
@@ -130,15 +131,14 @@
* @param tree Input EL description tree.
* @return Set of refined EL description trees.
*/
- public Set<ELDescriptionTree> refine(ELDescriptionTree tree) {
+ public List<ELDescriptionTree> refine(ELDescriptionTree tree) {
logger.trace("applying \\rho on " + tree.toDescriptionString());
-// System.out.println("tree:" + tree);
- Set<ELDescriptionTree> refinements = new HashSet<ELDescriptionTree>();
+ List<ELDescriptionTree> refinements = new LinkedList<ELDescriptionTree>();
// loop over all nodes of the tree and perform one of the
// transformations on it (we make a copy of all nodes, because
// the transformations can, of course, add new nodes)
- Set<ELDescriptionNode> nodes = new HashSet<ELDescriptionNode>(tree.getNodes());
+ List<ELDescriptionNode> nodes = new LinkedList<ELDescriptionNode>(tree.getNodes());
for(ELDescriptionNode v : nodes) {
logger.trace("picked node v: " + v);
@@ -154,20 +154,13 @@
refinements.addAll(attachSubtree(tree, v, position));
}
-// for(ELDescriptionTree refinement : refinements) {
-// if(refinement.getDepth() > tree.getDepth() + 1) {
-// throw new Error("DEPTH WARNING");
-// }
-// }
-
-// return refine(tree, tree.getRootNode(), new Thing(), true);
return refinements;
}
// operation 1: label extension
- private Set<ELDescriptionTree> extendLabel(ELDescriptionTree tree, ELDescriptionNode v, int[] position) {
+ private List<ELDescriptionTree> extendLabel(ELDescriptionTree tree, ELDescriptionNode v, int[] position) {
Monitor mon = MonitorFactory.start("extend label");
- Set<ELDescriptionTree> refinements = new HashSet<ELDescriptionTree>();
+ List<ELDescriptionTree> refinements = new LinkedList<ELDescriptionTree>();
// the index is the range of role in the edge pointing to the parent of this node
Description index;
@@ -179,10 +172,8 @@
// call ncc (see paper)
Set<NamedClass> candidates = utility.getClassCandidates(index, v.getLabel());
-// System.out.println("label: " + v.getLabel());
for(NamedClass nc : candidates) {
-// System.out.println("candidate: " + nc);
// clone operation
ELDescriptionTree clonedTree = tree.clone();
ELDescriptionNode clonedNode = clonedTree.getNode(position);
@@ -198,9 +189,9 @@
}
// operation 2: label refinement
- private Set<ELDescriptionTree> refineLabel(ELDescriptionTree tree, ELDescriptionNode v, int[] position) {
+ private List<ELDescriptionTree> refineLabel(ELDescriptionTree tree, ELDescriptionNode v, int[] position) {
Monitor mon = MonitorFactory.start("refine label");
- Set<ELDescriptionTree> refinements = new HashSet<ELDescriptionTree>();
+ List<ELDescriptionTree> refinements = new LinkedList<ELDescriptionTree>();
// loop through all classes in label
for(NamedClass nc : v.getLabel()) {
@@ -225,9 +216,9 @@
}
// operation 3: refine edge
- private Set<ELDescriptionTree> refineEdge(ELDescriptionTree tree, ELDescriptionNode v, int[] position) {
+ private List<ELDescriptionTree> refineEdge(ELDescriptionTree tree, ELDescriptionNode v, int[] position) {
Monitor mon = MonitorFactory.start("refine edge");
- Set<ELDescriptionTree> refinements = new HashSet<ELDescriptionTree>();
+ List<ELDescriptionTree> refinements = new LinkedList<ELDescriptionTree>();
for(int edgeNumber = 0; edgeNumber < v.getEdges().size(); edgeNumber++) {
ELDescriptionEdge edge = v.getEdges().get(edgeNumber);
@@ -256,9 +247,9 @@
}
// operation 4: attach tree
- private Set<ELDescriptionTree> attachSubtree(ELDescriptionTree tree, ELDescriptionNode v, int[] position) {
+ private List<ELDescriptionTree> attachSubtree(ELDescriptionTree tree, ELDescriptionNode v, int[] position) {
Monitor mon = MonitorFactory.start("attach tree");
- Set<ELDescriptionTree> refinements = new HashSet<ELDescriptionTree>();
+ List<ELDescriptionTree> refinements = new LinkedList<ELDescriptionTree>();
// compute the set of most general roles such that the domain of each role is not disjoint
// with the range of the role pointing to this node
@@ -268,12 +259,14 @@
} else {
index = opRanges.get(v.getParentEdge().getLabel());
}
+
SortedSet<ObjectProperty> appOPs = utility.computeApplicableObjectProperties(index);
+
Set<ObjectProperty> mgr = utility.computeMgr(appOPs);
// loop through most general roles
for(ObjectProperty op : mgr) {
- logger.trace("pick most general role: " + op);
+// logger.trace("pick most general role: " + op);
// a list of subtrees (stored as edges i.e. role + root node which points to tree)
LinkedList<ELDescriptionEdge> m = new LinkedList<ELDescriptionEdge>();
@@ -288,7 +281,7 @@
while(!m.isEmpty()) {
// pick and remove first element
ELDescriptionEdge edge = m.pollFirst();
- logger.trace("picked first element of M: " + edge);
+// logger.trace("picked first element of M: " + edge);
ObjectProperty r = edge.getLabel();
// tp = t' in algorithm description (p stands for prime)
ELDescriptionTree tp = edge.getNode().getTree();
@@ -299,29 +292,24 @@
// the position of w is the position of v + #edges outgoing from v
int[] wPosition = new int[position.length+1];
System.arraycopy(position, 0, wPosition, 0, position.length);
- wPosition[position.length] = v.getEdges().size();
-// logger.trace("position of v: " + arrayContent(position));
-// logger.trace("position of w: " + arrayContent(wPosition));
+ wPosition[position.length] = v.getEdges().size();
-
ELDescriptionNode wClone = mergedTree.getNode(wPosition);
- logger.trace("merged to t_{C'}: \n" + mergedTree);
+// logger.trace("merged to t_{C'}: \n" + mergedTree);
-// System.out.println(mergedTree.toSimulationString());
-
// we check equivalence by a minimality test (TODO: can we still do this?)
boolean minimal = mergedTree.isMinimal();
MonitorFactory.add("as.minimal", "boolean", minimal ? 1 : 0);
if(minimal) {
- logger.trace("Merged tree is minimal, i.e. not equivalent.");
+// logger.trace("Merged tree is minimal, i.e. not equivalent.");
// it is not equivalent, i.e. we found a refinement
refinements.add(mergedTree);
} else {
- logger.trace("Merged tree is not minimal, i.e. equivalent.");
+// logger.trace("Merged tree is not minimal, i.e. equivalent.");
// perform complex check in merged tree
boolean check = asCheck(wClone);
- logger.trace("Result of complex check: " + check);
+// logger.trace("Result of complex check: " + check);
MonitorFactory.add("as.check", "boolean", check ? 1 : 0);
if(check) {
@@ -330,20 +318,19 @@
m.add(new ELDescriptionEdge(subRole, tp.getRootNode()));
}
// refine tree using recursive operator call
- logger.trace("Recursive Call");
+// logger.trace("Recursive Call");
// do not monitor recursive calls (counts time twice or more)
mon.stop();
- Set<ELDescriptionTree> recRefs = refine(tp);
+ List<ELDescriptionTree> recRefs = refine(tp);
mon.start();
- logger.trace("Recursive Call Done");
+// logger.trace("Recursive Call Done");
for(ELDescriptionTree tpp : recRefs) {
-// System.out.println("aa " + tpp.toDescriptionString());
m.add(new ELDescriptionEdge(r, tpp.getRootNode()));
}
}
}
- logger.trace("M: " + m);
+// logger.trace("M: " + m);
}
}
mon.stop();
@@ -352,7 +339,7 @@
// create a new tree which is obtained by attaching the new tree at the given node in the tree via role r
private ELDescriptionTree mergeTrees(ELDescriptionTree tree, ELDescriptionNode node, int[] position, ObjectProperty r, ELDescriptionTree newTree) {
- Monitor mon = MonitorFactory.start("merge trees");
+ Monitor mon = MonitorFactory.start("as.merge trees");
// System.out.println("merge start");
// System.out.println(tree);
// System.out.println(newTree);
@@ -365,15 +352,15 @@
// logger.trace("node position: " + arrayContent(position));
// logger.trace("merge start: " + mergedTree);
-
// create a list of nodes we still need to process
LinkedList<ELDescriptionNode> toProcess = new LinkedList<ELDescriptionNode>();
toProcess.add(newTree.getRootNode());
// map from nodes to cloned nodes
Map<ELDescriptionNode,ELDescriptionNode> cloneMap = new HashMap<ELDescriptionNode,ELDescriptionNode>();
-// cloneMap.put(newTree.getRootNode(), nodeNew);
+// Monitor mon2 = MonitorFactory.start("as.tmp");
+
// loop until the process list is empty
while(!toProcess.isEmpty()) {
// process a node
@@ -397,14 +384,15 @@
}
}
-// System.out.println(mergedTree);
-// System.out.println("merge end");
+// mon2.stop();
+
mon.stop();
return mergedTree;
}
// TODO: variables have been renamed in article
public boolean asCheck(ELDescriptionNode v) {
+ Monitor mon = MonitorFactory.start("as.complex check");
// System.out.println("asCheck: " + v.getTree().toSimulationString());
// find all edges up to the root node
@@ -442,6 +430,7 @@
}
}
+ mon.stop();
return true;
}
Modified: trunk/src/dl-learner/org/dllearner/refinementoperators/Utility.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/refinementoperators/Utility.java 2009-01-11 07:56:41 UTC (rev 1573)
+++ trunk/src/dl-learner/org/dllearner/refinementoperators/Utility.java 2009-01-11 11:53:29 UTC (rev 1574)
@@ -38,6 +38,9 @@
import org.dllearner.utilities.Helper;
import org.dllearner.utilities.owl.ConceptComparator;
+import com.jamonapi.Monitor;
+import com.jamonapi.MonitorFactory;
+
/**
* Utility methods for constructing refinement operators.
*
@@ -46,8 +49,9 @@
*/
public final class Utility {
- private ReasonerComponent rs;
+ private ReasonerComponent reasoner;
ClassHierarchy sh;
+ private Map<ObjectProperty,Description> opDomains;
// concept comparator
private ConceptComparator conceptComparator = new ConceptComparator();
@@ -59,10 +63,18 @@
// cache for reasoner queries
private Map<Description,Map<Description,Boolean>> cachedDisjoints = new TreeMap<Description,Map<Description,Boolean>>(conceptComparator);
-
+ // cache for applicaple object properties
+ private Map<Description, SortedSet<ObjectProperty>> appOPCache = new TreeMap<Description, SortedSet<ObjectProperty>>(conceptComparator);
+
public Utility(ReasonerComponent rs) {
- this.rs = rs;
+ throw new Error("not implemented yet");
+ }
+
+ public Utility(ReasonerComponent rs, Map<ObjectProperty,Description> opDomains) {
+ this.reasoner = rs;
sh = rs.getClassHierarchy();
+ // we cache object property domains
+ this.opDomains = opDomains;
}
/**
@@ -76,12 +88,18 @@
*
*/
public SortedSet<ObjectProperty> computeApplicableObjectProperties(Description index) {
- Set<ObjectProperty> objectProperties = rs.getObjectProperties();
- SortedSet<ObjectProperty> applicableObjectProperties = new TreeSet<ObjectProperty>();
- for(ObjectProperty op : objectProperties) {
- Description domain = rs.getDomain(op);
- if(!isDisjoint(index,domain))
- applicableObjectProperties.add(op);
+ // use a cache, because large ontologies can have many object properties
+ SortedSet<ObjectProperty> applicableObjectProperties = appOPCache.get(index);
+ if(applicableObjectProperties == null) {
+ Set<ObjectProperty> objectProperties = reasoner.getObjectProperties();
+ applicableObjectProperties = new TreeSet<ObjectProperty>();
+ for(ObjectProperty op : objectProperties) {
+ Description domain = opDomains.get(op);
+ if(!isDisjoint(index,domain)) {
+ applicableObjectProperties.add(op);
+ }
+ }
+ appOPCache.put(index, applicableObjectProperties);
}
return applicableObjectProperties;
}
@@ -99,7 +117,7 @@
* @return The most general applicable properties.
*/
public SortedSet<ObjectProperty> computeMgr(SortedSet<ObjectProperty> applicableObjectProperties) {
- return Helper.intersection(rs.getMostGeneralProperties(), applicableObjectProperties);
+ return Helper.intersection(reasoner.getMostGeneralProperties(), applicableObjectProperties);
}
public Set<NamedClass> getClassCandidates(Description index, Set<NamedClass> existingClasses) {
@@ -190,7 +208,9 @@
result = isDisjointInstanceBased(d1,d2);
} else {
Description d = new Intersection(d1, d2);
- result = rs.isSuperClassOf(new Nothing(), d);
+ Monitor mon = MonitorFactory.start("disjointness reasoning");
+ result = reasoner.isSuperClassOf(new Nothing(), d);
+ mon.stop();
}
// add the result to the cache (we add it twice such that
// the order of access does not matter)
@@ -213,8 +233,8 @@
}
private boolean isDisjointInstanceBased(Description d1, Description d2) {
- SortedSet<Individual> d1Instances = rs.getIndividuals(d1);
- SortedSet<Individual> d2Instances = rs.getIndividuals(d2);
+ SortedSet<Individual> d1Instances = reasoner.getIndividuals(d1);
+ SortedSet<Individual> d2Instances = reasoner.getIndividuals(d2);
for(Individual d1Instance : d1Instances) {
if(d2Instances.contains(d1Instance))
return false;
Modified: trunk/src/dl-learner/org/dllearner/scripts/evaluation/ELOperatorBenchmark.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/scripts/evaluation/ELOperatorBenchmark.java 2009-01-11 07:56:41 UTC (rev 1573)
+++ trunk/src/dl-learner/org/dllearner/scripts/evaluation/ELOperatorBenchmark.java 2009-01-11 11:53:29 UTC (rev 1574)
@@ -20,23 +20,13 @@
package org.dllearner.scripts.evaluation;
import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
import java.io.IOException;
-import java.net.MalformedURLException;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Calendar;
import java.util.Date;
-import java.util.GregorianCalendar;
+import java.util.List;
import java.util.Random;
-import java.util.Set;
-import org.apache.log4j.FileAppender;
-import org.apache.log4j.Level;
-import org.apache.log4j.Logger;
-import org.apache.log4j.SimpleLayout;
import org.dllearner.algorithms.el.ELDescriptionTree;
import org.dllearner.core.ComponentInitException;
import org.dllearner.core.ComponentManager;
@@ -171,7 +161,7 @@
System.out.print("current concept: " + currTree.transformToDescription().toString(reasoner.getBaseURI(), reasoner.getPrefixes()));
// apply operator on current description
long start = System.nanoTime();
- Set<ELDescriptionTree> refinements = operator.refine(currTree);
+ List<ELDescriptionTree> refinements = operator.refine(currTree);
long time = System.nanoTime() - start;
runtime.addNumber(time/1000000d);
runtimePerRefinement.addNumber(time/1000000d/refinements.size());
@@ -181,6 +171,7 @@
int sizeSum = 0;
for(ELDescriptionTree tree : refinements) {
+// System.out.println(" " + tree.toDescriptionString());
sizeSum += tree.getSize();
}
@@ -191,7 +182,8 @@
// pick a refinement randomly (which is kind of slow for a set, but
// this does not matter here)
int index = rand.nextInt(refinements.size());
- currTree = new ArrayList<ELDescriptionTree>(refinements).get(index);
+// currTree = new ArrayList<ELDescriptionTree>(refinements).get(index);
+ currTree = refinements.get(index);
MonitorFactory.add("picked refinement size", "count", currTree.getSize());
}
System.out.println("operator time: " + runtime.prettyPrint("ms"));
@@ -218,10 +210,15 @@
statString += getMonitorData(MonitorFactory.getMonitor("refine label", "ms."));
statString += getMonitorData(MonitorFactory.getMonitor("refine edge", "ms."));
statString += getMonitorData(MonitorFactory.getMonitor("attach tree", "ms."));
+ statString += getMonitorData(MonitorFactory.getMonitor("as.merge trees", "ms."));
+ statString += getMonitorData(MonitorFactory.getMonitor("as.complex check", "ms."));
+// statString += getMonitorData(MonitorFactory.getMonitor("as.tmp", "ms."));
+// statString += getMonitorData(MonitorFactory.getMonitor("el.tmp", "ms."));
statString += getMonitorDataBoolean(MonitorFactory.getMonitor("as.minimal", "boolean"));
statString += getMonitorDataBoolean(MonitorFactory.getMonitor("as.check", "boolean"));
statString += getMonitorData(MonitorFactory.getMonitor("tree clone", "ms."));
statString += getMonitorData(MonitorFactory.getMonitor("simulation update", "ms."));
+ statString += getMonitorData(MonitorFactory.getMonitor("disjointness reasoning", "ms."));
Files.createFile(statFile, statString);
}
Modified: trunk/src/dl-learner/org/dllearner/test/junit/ELDownTests.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/test/junit/ELDownTests.java 2009-01-11 07:56:41 UTC (rev 1573)
+++ trunk/src/dl-learner/org/dllearner/test/junit/ELDownTests.java 2009-01-11 11:53:29 UTC (rev 1574)
@@ -136,12 +136,12 @@
// number of refinements has to be correct and each produced
// refinement must be in the set of desired refinements
-// assertTrue(refinements.size() == desired.size());
+ assertTrue(refinements.size() == desired.size());
System.out.println("\nproduced refinements and their unit test status (true = assertion satisfied):");
for(Description refinement : refinements) {
boolean ok = desired.contains(refinement);
System.out.println(ok + ": " + refinement.toString(KBParser.internalNamespace, null));
-// assertTrue(desired.contains(refinement));
+ assertTrue(desired.contains(refinement));
}
File jamonlog = new File("log/jamontest.html");
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
