Menu
▾
▴
[DL-Learner SVN] SF.net SVN: dl-learner:[4262] trunk
|
From: <lor...@us...> - 2014-05-07 13:43:59
|
Revision: 4262
http://sourceforge.net/p/dl-learner/code/4262
Author: lorenz_b
Date: 2014-05-07 13:43:54 +0000 (Wed, 07 May 2014)
Log Message:
-----------
Updated libs.
Modified Paths:
--------------
trunk/components-core/pom.xml
trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/ELLearningAlgorithm.java
trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/SearchTreeNode.java
trunk/components-core/src/main/java/org/dllearner/algorithms/isle/metrics/AbstractRelevanceMetric.java
trunk/components-core/src/main/java/org/dllearner/algorithms/isle/metrics/RelevanceMetric.java
trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2Disjunctive.java
trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/datastructures/impl/QueryTreeImpl.java
trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/impl/QueryTreeFactoryImpl.java
trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/operations/lgg/LGGGeneratorImpl.java
trunk/components-core/src/main/java/org/dllearner/core/AbstractCELA.java
trunk/components-core/src/main/java/org/dllearner/core/AbstractReasonerComponent.java
trunk/components-core/src/main/java/org/dllearner/core/owl/ClassHierarchy.java
trunk/components-core/src/main/java/org/dllearner/kb/OWLAPIOntology.java
trunk/components-core/src/main/java/org/dllearner/kb/aquisitors/SparqlTupleAquisitorImproved.java
trunk/components-core/src/main/java/org/dllearner/learningproblems/PosNegLPStandard.java
trunk/components-core/src/main/java/org/dllearner/reasoning/FastInstanceChecker.java
trunk/components-core/src/main/java/org/dllearner/reasoning/OWLAPIReasoner.java
trunk/components-core/src/main/java/org/dllearner/reasoning/SPARQLReasoner.java
trunk/components-core/src/main/java/org/dllearner/refinementoperators/RhoDRDown.java
trunk/components-core/src/main/java/org/dllearner/utilities/examples/AutomaticNegativeExampleFinderSPARQL2.java
trunk/components-core/src/main/resources/log4j.properties
trunk/components-core/src/test/java/org/dllearner/algorithms/isle/DBpediaExperiment.java
trunk/components-core/src/test/java/org/dllearner/algorithms/qtl/LGGTest.java
trunk/components-core/src/test/java/org/dllearner/algorithms/qtl/QALDExperiment.java
trunk/components-core/src/test/java/org/dllearner/algorithms/qtl/QTLTest.java
trunk/components-core/src/test/java/org/dllearner/algorithms/qtl/TreeSubsumptionTest.java
trunk/examples/family-benchmark/Brother.conf
trunk/interfaces/src/main/java/org/dllearner/cli/CLI.java
trunk/interfaces/src/main/java/org/dllearner/cli/CrossValidation.java
trunk/interfaces/src/main/java/org/dllearner/cli/SPARQLCrossValidation.java
trunk/pom.xml
trunk/protege/src/main/resources/META-INF/MANIFEST.MF
trunk/scripts/pom.xml
trunk/scripts/src/main/java/org/dllearner/scripts/evaluation/QTLEvaluation.java
Added Paths:
-----------
trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/DefaultRelevanceWeightings.java
trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/RelevanceWeightedStableHeuristic.java
trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/RelevanceWeightings.java
trunk/components-core/src/main/java/org/dllearner/algorithms/isle/index/syntactic/EntityFrequencyCache.java
trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2DisjunctiveMT.java
trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QueryTreeHeuristic.java
trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/util/QueryTreeConverter.java
Removed Paths:
-------------
trunk/test/fuzzydll/fuzzyOWL2fuzzyDLparserOutput.fuzzyDL.txt
Modified: trunk/components-core/pom.xml
===================================================================
--- trunk/components-core/pom.xml 2014-05-07 11:25:54 UTC (rev 4261)
+++ trunk/components-core/pom.xml 2014-05-07 13:43:54 UTC (rev 4262)
@@ -232,10 +232,10 @@
<artifactId>commons-pool</artifactId>
</dependency>
<dependency>
- <groupId>org.semanticweb.elk</groupId>
- <artifactId>elk-owlapi</artifactId>
- <version>0.3.0</version>
- </dependency>
+ <groupId>org.semanticweb.elk</groupId>
+ <artifactId>elk-owlapi</artifactId>
+ <version>0.4.1</version>
+</dependency>
<dependency>
<groupId>de.tudresden.inf.lat.cel</groupId>
<artifactId>reasoner</artifactId>
@@ -281,7 +281,7 @@
<dependency>
<groupId>org.aksw.jena-sparql-api</groupId>
<artifactId>jena-sparql-api-core</artifactId>
- <version>2.10.0-5-SNAPSHOT</version>
+ <version>2.10.0-8</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
Added: trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/DefaultRelevanceWeightings.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/DefaultRelevanceWeightings.java (rev 0)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/DefaultRelevanceWeightings.java 2014-05-07 13:43:54 UTC (rev 4262)
@@ -0,0 +1,31 @@
+/**
+ *
+ */
+package org.dllearner.algorithms.elcopy;
+
+import org.dllearner.algorithms.isle.metrics.ChiSquareRelevanceMetric;
+import org.dllearner.algorithms.isle.metrics.DiceRelevanceMetric;
+import org.dllearner.algorithms.isle.metrics.JaccardRelevanceMetric;
+import org.dllearner.algorithms.isle.metrics.LLRRelevanceMetric;
+import org.dllearner.algorithms.isle.metrics.PMIRelevanceMetric;
+import org.dllearner.algorithms.isle.metrics.SCIRelevanceMetric;
+import org.dllearner.algorithms.isle.metrics.SignificantPMIRelevanceMetric;
+import org.dllearner.algorithms.isle.metrics.TTestRelevanceMetric;
+
+/**
+ * @author Lorenz Buehmann
+ *
+ */
+public class DefaultRelevanceWeightings extends RelevanceWeightings{
+
+ public DefaultRelevanceWeightings() {
+ put(PMIRelevanceMetric.class, 1.0);
+ put(SignificantPMIRelevanceMetric.class, 1.0);
+ put(ChiSquareRelevanceMetric.class, 1.0);
+ put(TTestRelevanceMetric.class, 1.0);
+ put(JaccardRelevanceMetric.class, 1.0);
+ put(DiceRelevanceMetric.class, 1.0);
+ put(SCIRelevanceMetric.class, 1.0);
+ put(LLRRelevanceMetric.class, 1.0);
+ }
+}
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/ELLearningAlgorithm.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/ELLearningAlgorithm.java 2014-05-07 11:25:54 UTC (rev 4261)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/ELLearningAlgorithm.java 2014-05-07 13:43:54 UTC (rev 4262)
@@ -45,6 +45,7 @@
import org.dllearner.learningproblems.EvaluatedDescriptionPosNeg;
import org.dllearner.learningproblems.PosNegLP;
import org.dllearner.learningproblems.ScorePosNeg;
+import org.dllearner.learningproblems.ScoreTwoValued;
import org.dllearner.refinementoperators.ELDown3;
import org.dllearner.utilities.Helper;
import org.dllearner.utilities.owl.EvaluatedDescriptionSet;
@@ -148,7 +149,10 @@
@Override
public void init() throws ComponentInitException {
// currently we use the stable heuristic
- heuristic = new StableHeuristic();
+ if(heuristic == null){
+ heuristic = new StableHeuristic();
+ }
+
candidates = new TreeSet<SearchTreeNode>(heuristic);
if(ignoredConcepts != null) {
@@ -167,6 +171,13 @@
bestEvaluatedDescriptions = new EvaluatedDescriptionSet(maxNrOfResults);
}
+ /**
+ * @param heuristic the heuristic to set
+ */
+ public void setHeuristic(ELHeuristic heuristic) {
+ this.heuristic = heuristic;
+ }
+
@Override
public void start() {
stop = false;
@@ -237,7 +248,13 @@
} else {
node.setCoveredNegatives(negCovers);
}
- node.setScore(accuracy);
+ node.setAccuracy(accuracy);
+ if(heuristic instanceof RelevanceWeightedStableHeuristic){
+ node.setScore(((RelevanceWeightedStableHeuristic)heuristic).getNodeScore(node));
+ } else {
+ node.setScore(accuracy);
+ }
+
// System.out.println(description + ":" + accuracy);
// link to parent (unless start node)
if(parentNode == null) {
@@ -259,6 +276,7 @@
// for fully computing the evaluated description
if(bestEvaluatedDescriptions.size() == 0 || ((EvaluatedDescriptionPosNeg)bestEvaluatedDescriptions.getWorst()).getCoveredNegatives().size() >= node.getCoveredNegatives()) {
ScorePosNeg score = (ScorePosNeg) learningProblem.computeScore(description);
+ ((ScoreTwoValued)score).setAccuracy(node.getScore());
EvaluatedDescriptionPosNeg ed = new EvaluatedDescriptionPosNeg(description, score);
bestEvaluatedDescriptions.add(ed);
}
@@ -329,7 +347,9 @@
//non of the equivalent classes must occur on the first level
TreeSet<Description> toTest = new TreeSet<Description>(descriptionComparator);
- toTest.add(classToDescribe);
+ if(classToDescribe != null){
+ toTest.add(classToDescribe);
+ }
while(!toTest.isEmpty()) {
Description d = toTest.pollFirst();
if(occursOnFirstLevel(description, d)) {
@@ -341,7 +361,9 @@
// none of the superclasses of the class to learn must appear on the
// outermost property level
TreeSet<Description> toTest = new TreeSet<Description>(descriptionComparator);
- toTest.add(classToDescribe);
+ if(classToDescribe != null){
+ toTest.add(classToDescribe);
+ }
while(!toTest.isEmpty()) {
Description d = toTest.pollFirst();
if(occursOnFirstLevel(description, d)) {
Added: trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/RelevanceWeightedStableHeuristic.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/RelevanceWeightedStableHeuristic.java (rev 0)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/RelevanceWeightedStableHeuristic.java 2014-05-07 13:43:54 UTC (rev 4262)
@@ -0,0 +1,124 @@
+/**
+ * Copyright (C) 2007-2011, 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/>.
+ */
+
+package org.dllearner.algorithms.elcopy;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.dllearner.algorithms.isle.metrics.RelevanceMetric;
+import org.dllearner.core.owl.Description;
+import org.dllearner.core.owl.Entity;
+import org.dllearner.core.owl.NamedClass;
+
+
+/**
+ * A stable comparator for search tree nodes. Stable means that the order
+ * of nodes will not change during the run of the learning algorithm. In
+ * this implementation, this is ensured by using only covered examples
+ * and tree size as criteria.
+ *
+ * @author Jens Lehmann
+ *
+ */
+public class RelevanceWeightedStableHeuristic implements ELHeuristic {
+
+ private ELDescriptionTreeComparator cmp = new ELDescriptionTreeComparator();
+ private RelevanceWeightings weightings;
+ private List<RelevanceMetric> relevanceMetrics;
+ private NamedClass classToDescribe;
+
+
+ public RelevanceWeightedStableHeuristic(NamedClass classToDescribe, RelevanceWeightings weightings, RelevanceMetric... relevanceMetrics) {
+ this.classToDescribe = classToDescribe;
+ this.weightings = weightings;
+ this.relevanceMetrics = Arrays.asList(relevanceMetrics);
+ }
+
+ public RelevanceWeightedStableHeuristic(NamedClass classToDescribe, RelevanceWeightings weightings, List<RelevanceMetric> relevanceMetrics) {
+ this.classToDescribe = classToDescribe;
+ this.weightings = weightings;
+ this.relevanceMetrics = relevanceMetrics;
+ }
+
+ public RelevanceWeightedStableHeuristic(NamedClass classToDescribe, RelevanceMetric... relevanceMetrics) {
+ this(classToDescribe, new DefaultRelevanceWeightings(), relevanceMetrics);
+ }
+
+ public RelevanceWeightedStableHeuristic(NamedClass classToDescribe, List<RelevanceMetric> relevanceMetrics) {
+ this(classToDescribe, new DefaultRelevanceWeightings(), relevanceMetrics);
+ }
+
+ /**
+ * @param weightings the weightings to set
+ */
+ public void setWeightings(RelevanceWeightings weightings) {
+ this.weightings = weightings;
+ }
+
+ /**
+ * @param relevanceMetrics the relevanceMetrics to set
+ */
+ public void setRelevanceMetrics(List<RelevanceMetric> relevanceMetrics) {
+ this.relevanceMetrics = relevanceMetrics;
+ }
+
+ /**
+ * @param classToDescribe the classToDescribe to set
+ */
+ public void setClassToDescribe(NamedClass classToDescribe) {
+ this.classToDescribe = classToDescribe;
+ }
+
+ public double getNodeScore(SearchTreeNode node){
+ double score = node.getAccuracy();
+ Description d = node.getDescriptionTree().transformToDescription();
+ for (RelevanceMetric metric : relevanceMetrics) {
+ score += weightings.getWeight(metric.getClass()) * metric.getRelevance(classToDescribe, d);
+ }
+ return score;
+ }
+
+ @Override
+ public int compare(SearchTreeNode o1, SearchTreeNode o2) {
+
+// int diff = o2.getCoveredNegatives() - o1.getCoveredNegatives();
+ double score1 = o1.getScore();
+ double score2 = o2.getScore();
+ int diff = Double.compare(score1, score2);
+ if(diff>0) {
+ return 1;
+ } else if(diff<0) {
+ return -1;
+ } else {
+
+ double sizeDiff = o2.getDescriptionTree().size - o1.getDescriptionTree().size;
+
+ if(sizeDiff == 0) {
+ return cmp.compare(o1.getDescriptionTree(), o2.getDescriptionTree());
+ } else if(sizeDiff>0) {
+ return 1;
+ } else {
+ return -1;
+ }
+
+ }
+ }
+
+}
Added: trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/RelevanceWeightings.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/RelevanceWeightings.java (rev 0)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/RelevanceWeightings.java 2014-05-07 13:43:54 UTC (rev 4262)
@@ -0,0 +1,24 @@
+/**
+ *
+ */
+package org.dllearner.algorithms.elcopy;
+
+import java.util.HashMap;
+
+import org.dllearner.algorithms.isle.metrics.RelevanceMetric;
+
+/**
+ * @author Lorenz Buehmann
+ *
+ */
+public class RelevanceWeightings extends HashMap<Class<? extends RelevanceMetric>, Double>{
+
+ public double getWeight(RelevanceMetric metric){
+ return get(metric.getClass());
+ }
+
+ public double getWeight(Class<? extends RelevanceMetric> metricClass){
+ return get(metricClass);
+ }
+
+}
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/SearchTreeNode.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/SearchTreeNode.java 2014-05-07 11:25:54 UTC (rev 4261)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/elcopy/SearchTreeNode.java 2014-05-07 13:43:54 UTC (rev 4262)
@@ -38,6 +38,7 @@
private boolean tooWeak = false;
private double score;
+ protected double accuracy;
public SearchTreeNode(ELDescriptionTree descriptionTree) {
this.descriptionTree = descriptionTree;
@@ -127,4 +128,18 @@
this.score = score;
}
+ /**
+ * @return the accuracy
+ */
+ public double getAccuracy() {
+ return accuracy;
+ }
+
+ /**
+ * @param accuracy the accuracy to set
+ */
+ public void setAccuracy(double accuracy) {
+ this.accuracy = accuracy;
+ }
+
}
Added: trunk/components-core/src/main/java/org/dllearner/algorithms/isle/index/syntactic/EntityFrequencyCache.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/isle/index/syntactic/EntityFrequencyCache.java (rev 0)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/isle/index/syntactic/EntityFrequencyCache.java 2014-05-07 13:43:54 UTC (rev 4262)
@@ -0,0 +1,17 @@
+/**
+ *
+ */
+package org.dllearner.algorithms.isle.index.syntactic;
+
+import java.util.HashMap;
+import java.util.Set;
+
+import org.dllearner.core.owl.Entity;
+
+/**
+ * @author Lorenz Buehmann
+ *
+ */
+public class EntityFrequencyCache extends HashMap<Set<Entity>, Long>{
+
+}
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/isle/metrics/AbstractRelevanceMetric.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/isle/metrics/AbstractRelevanceMetric.java 2014-05-07 11:25:54 UTC (rev 4261)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/isle/metrics/AbstractRelevanceMetric.java 2014-05-07 13:43:54 UTC (rev 4262)
@@ -5,8 +5,10 @@
import java.util.HashMap;
import java.util.Map;
+import java.util.Set;
import org.dllearner.algorithms.isle.index.Index;
+import org.dllearner.core.owl.Description;
import org.dllearner.core.owl.Entity;
/**
@@ -16,9 +18,12 @@
public abstract class AbstractRelevanceMetric implements RelevanceMetric {
protected Index index;
+ protected String name;
public AbstractRelevanceMetric(Index index) {
this.index = index;
+
+ name = getClass().getSimpleName().replace("RelevanceMetric", "");
}
public static Map<Entity, Double> normalizeMinMax(Map<Entity, Double> hmEntity2Score) {
@@ -53,5 +58,47 @@
}
return hmEntity2Norm;
}
+
+ public String getName() {
+ return name;
+ }
+
+ public double getRelevance(Entity entity, Description desc){
+ Set<Entity> entities = desc.getSignature();
+ double score = 0;
+ for (Entity otherEntity : entities) {
+ double relevance = getRelevance(entity, otherEntity);
+ if(!Double.isInfinite(relevance)){
+ score += relevance/entities.size();
+ }
+ }
+ return score;
+ }
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + ((name == null) ? 0 : name.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ AbstractRelevanceMetric other = (AbstractRelevanceMetric) obj;
+ if (name == null) {
+ if (other.name != null)
+ return false;
+ } else if (!name.equals(other.name))
+ return false;
+ return true;
+ }
+
+
}
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/isle/metrics/RelevanceMetric.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/isle/metrics/RelevanceMetric.java 2014-05-07 11:25:54 UTC (rev 4261)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/isle/metrics/RelevanceMetric.java 2014-05-07 13:43:54 UTC (rev 4262)
@@ -20,6 +20,7 @@
package org.dllearner.algorithms.isle.metrics;
+import org.dllearner.core.owl.Description;
import org.dllearner.core.owl.Entity;
@@ -38,4 +39,6 @@
* @return
*/
double getNormalizedRelevance(Entity entity1, Entity entity2);
+
+ double getRelevance(Entity entity, Description desc);
}
\ No newline at end of file
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2Disjunctive.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2Disjunctive.java 2014-05-07 11:25:54 UTC (rev 4261)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2Disjunctive.java 2014-05-07 13:43:54 UTC (rev 4262)
@@ -1,5 +1,6 @@
package org.dllearner.algorithms.qtl;
+import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
@@ -28,14 +29,19 @@
import org.dllearner.core.ComponentInitException;
import org.dllearner.core.EvaluatedDescription;
import org.dllearner.core.KnowledgeSource;
+import org.dllearner.core.LearningProblem;
import org.dllearner.core.LearningProblemUnsupportedException;
+import org.dllearner.core.Score;
+import org.dllearner.core.config.ConfigOption;
import org.dllearner.core.owl.Description;
import org.dllearner.core.owl.Individual;
import org.dllearner.core.owl.Union;
+import org.dllearner.kb.OWLAPIOntology;
import org.dllearner.kb.OWLFile;
import org.dllearner.learningproblems.Heuristics;
import org.dllearner.learningproblems.PosNegLP;
import org.dllearner.learningproblems.QueryTreeScore;
+import org.dllearner.learningproblems.ScoreTwoValued;
import org.dllearner.utilities.owl.DLLearnerDescriptionConvertVisitor;
import org.dllearner.utilities.owl.OWLAPIConverter;
import org.semanticweb.owlapi.io.ToStringRenderer;
@@ -51,12 +57,12 @@
import com.jamonapi.MonitorFactory;
@ComponentAnn(name="query tree learner with noise (disjunctive)", shortName="qtl2dis", version=0.8)
-public class QTL2Disjunctive extends AbstractCELA {
+public class QTL2Disjunctive extends AbstractCELA implements Cloneable{
private static final Logger logger = Logger.getLogger(QTL2Disjunctive.class.getName());
- private LGGGenerator<String> lggGenerator = new LGGGeneratorImpl<String>();
+ private LGGGenerator<String> lggGenerator;
private Queue<EvaluatedQueryTree<String>> todoList;
private SortedSet<EvaluatedQueryTree<String>> currentPartialSolutions;
@@ -69,9 +75,6 @@
private Set<Individual> currentNegExamples;
private Map<QueryTree<String>, Individual> tree2Individual;
-
- private double coverageWeight = 0.8;
- private double specifityWeight = 0.2;
private QueryTreeCache treeCache;
@@ -79,8 +82,6 @@
private Model model;
- private AbstractReasonerComponent reasoner;
-
private volatile boolean stop;
private boolean isRunning;
@@ -89,16 +90,39 @@
private List<EvaluatedQueryTree<String>> partialSolutions;
+ private EvaluatedDescription currentBestSolution;
+
+
+
+ //Parameters
+ @ConfigOption(name = "noisePercentage", defaultValue="0.0", description="the (approximated) percentage of noise within the examples")
+ private double noisePercentage = 0.0;
+ @ConfigOption(defaultValue = "10", name = "maxExecutionTimeInSeconds", description = "maximum execution of the algorithm in seconds")
+ private int maxExecutionTimeInSeconds = 10;
+ private double minimumTreeScore = 0.2;
+ private double coverageWeight = 0.8;
+ private double specifityWeight = 0.1;
+ private double noise = 0.3;
+ private double coverageBeta = 0.7;
+
+ private double posExampleWeight = 1;
+
public QTL2Disjunctive() {}
public QTL2Disjunctive(PosNegLP learningProblem, AbstractReasonerComponent reasoner) throws LearningProblemUnsupportedException{
- this.lp = learningProblem;
- this.reasoner = reasoner;
+ super(learningProblem, reasoner);
+ loadModel();
}
- public QTL2Disjunctive(PosNegLP lp, Model model) {
- this.lp = lp;
- this.model = model;
+// public QTL2Disjunctive(PosNegLP lp, Model model) {
+// this.learningProblem = lp;
+// this.model = model;
+// }
+
+ public QTL2Disjunctive(QTL2Disjunctive qtl) {
+ super(qtl.getLearningProblem(), qtl.getReasoner());
+ this.model = ModelFactory.createDefaultModel();
+ this.model.add(qtl.model);
}
public EvaluatedQueryTree<String> getBestSolution(){
@@ -110,6 +134,14 @@
*/
@Override
public void init() throws ComponentInitException {
+
+ if(!(learningProblem instanceof PosNegLP)){
+ throw new IllegalArgumentException("Only PosNeg learning problems are supported");
+ }
+ lp = (PosNegLP) learningProblem;
+
+ lggGenerator = new LGGGeneratorImpl<String>();
+
logger.info("Initializing...");
treeCache = new QueryTreeCache(model);
tree2Individual = new HashMap<QueryTree<String>, Individual>(lp.getPositiveExamples().size()+lp.getNegativeExamples().size());
@@ -120,6 +152,18 @@
currentNegExamples = new TreeSet<Individual>(lp.getNegativeExamples());
//get the query trees
+ generateTrees();
+
+ //some logging
+ subMon = MonitorFactory.getTimeMonitor("subsumption-mon");
+ lggMon = MonitorFactory.getTimeMonitor("lgg-mon");
+
+ //console rendering of class expressions
+ ToStringRenderer.getInstance().setRenderer(new ManchesterOWLSyntaxOWLObjectRendererImpl());
+ ToStringRenderer.getInstance().setShortFormProvider(new SimpleShortFormProvider());
+ }
+
+ private void generateTrees(){
QueryTree<String> queryTree;
for (Individual ind : lp.getPositiveExamples()) {
queryTree = treeCache.getQueryTree(ind.getName());
@@ -131,14 +175,6 @@
tree2Individual.put(queryTree, ind);
currentNegExampleTrees.add(queryTree);
}
-
- //some logging
- subMon = MonitorFactory.getTimeMonitor("subsumption-mon");
- lggMon = MonitorFactory.getTimeMonitor("lgg-mon");
-
- //console rendering of class expressions
- ToStringRenderer.getInstance().setRenderer(new ManchesterOWLSyntaxOWLObjectRendererImpl());
- ToStringRenderer.getInstance().setShortFormProvider(new SimpleShortFormProvider());
}
/* (non-Javadoc)
@@ -146,6 +182,11 @@
*/
@Override
public void start() {
+ String setup = "Setup:";
+ setup += "#Pos. examples:" + currentPosExamples.size();
+ setup += "#Neg. examples:" + currentNegExamples.size();
+ setup += "Coverage beta:" + coverageBeta;
+ logger.info(setup);
logger.info("Running...");
long startTime = System.currentTimeMillis();
@@ -180,6 +221,7 @@
currentNegExamples.remove(tree2Individual.get(tree));
}
}
+ currentBestSolution = buildCombinedSolution();
} while (!(stop || currentPosExampleTrees.isEmpty()));
isRunning = false;
@@ -187,22 +229,53 @@
long endTime = System.currentTimeMillis();
logger.info("Finished in " + (endTime-startTime) + "ms.");
- EvaluatedDescription combinedSolution = buildCombinedSolution();
- System.out.println(OWLAPIConverter.getOWLAPIDescription(combinedSolution.getDescription()));
+ logger.info("Combined solution:\n" + OWLAPIConverter.getOWLAPIDescription(currentBestSolution.getDescription()));
+ logger.info(currentBestSolution.getScore());
}
private EvaluatedDescription buildCombinedSolution(){
+ if(partialSolutions.size() == 1){
+ EvaluatedDescription combinedSolution = partialSolutions.get(0).asEvaluatedDescription();
+ double accuracy = lp.getAccuracy(combinedSolution.getDescription());
+ System.out.println(accuracy);
+ return combinedSolution;
+ }
List<Description> disjuncts = new ArrayList<Description>();
+
+ Set<Individual> posCovered = new HashSet<Individual>();
+ Set<Individual> negCovered = new HashSet<Individual>();
+
+ //build the union of all class expressions
Description partialDescription;
for (EvaluatedQueryTree<String> partialSolution : partialSolutions) {
partialDescription = DLLearnerDescriptionConvertVisitor.getDLLearnerDescription(
partialSolution.getTree().asOWLClassExpression(LiteralNodeConversionStrategy.FACET_RESTRICTION));
disjuncts.add(partialDescription);
+ posCovered.addAll(partialSolution.getTreeScore().getCoveredPositives());
+ negCovered.addAll(partialSolution.getTreeScore().getCoveredNegatives());
}
Description unionDescription = new Union(disjuncts);
- return new EvaluatedDescription(unionDescription, null);
+ Set<Individual> posNotCovered = Sets.difference(lp.getPositiveExamples(), posCovered);
+ Set<Individual> negNotCovered = Sets.difference(lp.getNegativeExamples(), negCovered);
+
+ double accuracy = lp.getAccuracy(unionDescription);
+ System.out.println(accuracy);
+
+ //compute the coverage
+ double recall = posCovered.size() / (double)lp.getPositiveExamples().size();
+ double precision = (posCovered.size() + negCovered.size() == 0)
+ ? 0
+ : posCovered.size() / (double)(posCovered.size() + negCovered.size());
+
+ double coverageScore = Heuristics.getFScore(recall, precision, coverageBeta);
+
+// ScoreTwoValued score = new ScoreTwoValued(posCovered, posNotCovered, negCovered, negNotCovered);
+// score.setAccuracy(coverageScore);
+ QueryTreeScore score = new QueryTreeScore(coverageScore, coverageScore, posCovered, posNotCovered, negCovered, negNotCovered, -1, -1);
+
+ return new EvaluatedDescription(unionDescription, score);
}
private void reset(){
@@ -216,6 +289,7 @@
}
private void computeLGG(){
+ logger.info("Computing best partial solution...");
currentlyBestScore = 0d;
initTodoList(currentPosExampleTrees, currentNegExampleTrees);
@@ -246,16 +320,17 @@
}
currentlyBestScore = solution.getScore();
}
+ currentPartialSolutions.add(currentElement);
}
currentPartialSolutions.add(currentElement);
// todoList.remove(currentElement);
} while(!terminationCriteriaSatisfied());
long endTime = System.currentTimeMillis();
- logger.info("Finished in " + (endTime-startTime) + "ms.");
- EvaluatedDescription bestSolution = getCurrentlyBestEvaluatedDescription();
+ logger.info("...finished in " + (endTime-startTime) + "ms.");
+ EvaluatedDescription bestPartialSolution = currentPartialSolutions.first().asEvaluatedDescription();
- logger.info("Best solution:\n" + OWLAPIConverter.getOWLAPIDescription(bestSolution.getDescription()) + "\n(" + bestSolution.getScore() + ")");
+ logger.info("Best partial solution:\n" + OWLAPIConverter.getOWLAPIDescription(bestPartialSolution.getDescription()) + "\n(" + bestPartialSolution.getScore() + ")");
logger.trace("LGG time: " + lggMon.getTotal() + "ms");
logger.trace("Avg. LGG time: " + lggMon.getAvg() + "ms");
@@ -278,7 +353,7 @@
*/
@Override
public Description getCurrentlyBestDescription() {
- return getCurrentlyBestEvaluatedDescription().getDescription();
+ return currentBestSolution.getDescription();
}
/* (non-Javadoc)
@@ -286,8 +361,7 @@
*/
@Override
public EvaluatedDescription getCurrentlyBestEvaluatedDescription() {
- EvaluatedQueryTree<String> bestSolution = currentPartialSolutions.first();
- return bestSolution.asEvaluatedDescription();
+ return currentBestSolution;
}
/* (non-Javadoc)
@@ -298,14 +372,18 @@
return isRunning;
}
+// @Autowired
+// public void setLearningProblem(PosNegLP learningProblem) {
+// this.lp = learningProblem;
+// }
+
@Autowired
- public void setLearningProblem(PosNegLP learningProblem) {
- this.lp = learningProblem;
+ public void setReasoner(AbstractReasonerComponent reasoner){
+ super.setReasoner(reasoner);
+ loadModel();
}
- @Autowired
- public void setReasoner(AbstractReasonerComponent reasoner){
- this.reasoner = reasoner;
+ private void loadModel(){
model = ModelFactory.createDefaultModel();
for (KnowledgeSource ks : reasoner.getSources()) {
if(ks instanceof OWLFile){
@@ -314,6 +392,14 @@
} catch (IOException e) {
e.printStackTrace();
}
+ } else if(ks instanceof OWLAPIOntology){
+ ByteArrayInputStream bais = new ByteArrayInputStream(((OWLAPIOntology) ks).getConverter().convert(((OWLAPIOntology) ks).getOntology()));
+ model.read(bais, null);
+ try {
+ bais.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
}
}
}
@@ -328,14 +414,14 @@
private EvaluatedQueryTree<String> evaluate(QueryTree<String> tree, boolean useSpecifity){
//1. get a score for the coverage = recall oriented
//compute positive examples which are not covered by LGG
- Set<QueryTree<String>> uncoveredPositiveExampleTrees = getUncoveredTrees(tree, currentPosExampleTrees);
- Set<Individual> uncoveredPosExamples = new HashSet<Individual>();
+ List<QueryTree<String>> uncoveredPositiveExampleTrees = getUncoveredTrees(tree, currentPosExampleTrees);
+ Set<Individual> uncoveredPosExamples = new TreeSet<Individual>();
for (QueryTree<String> queryTree : uncoveredPositiveExampleTrees) {
uncoveredPosExamples.add(tree2Individual.get(queryTree));
}
//compute negative examples which are covered by LGG
Collection<QueryTree<String>> coveredNegativeExampleTrees = getCoveredTrees(tree, currentNegExampleTrees);
- Set<Individual> coveredNegExamples = new HashSet<Individual>();
+ Set<Individual> coveredNegExamples = new TreeSet<Individual>();
for (QueryTree<String> queryTree : coveredNegativeExampleTrees) {
coveredNegExamples.add(tree2Individual.get(queryTree));
}
@@ -346,7 +432,8 @@
? 0
: coveredPositiveExamples / (double)(coveredPositiveExamples + coveredNegativeExampleTrees.size());
- double coverageScore = Heuristics.getFScore(recall, precision);
+ double beta = 0.5;
+ double coverageScore = Heuristics.getFScore(recall, precision, beta);
//2. get a score for the specifity of the query, i.e. how many edges/nodes = precision oriented
int nrOfSpecificNodes = 0;
@@ -364,8 +451,8 @@
double score = coverageWeight * coverageScore + specifityWeight * specifityScore;
QueryTreeScore queryTreeScore = new QueryTreeScore(score, coverageScore,
- Sets.difference(currentPosExamples, uncoveredPosExamples), uncoveredPosExamples,
- coveredNegExamples, Sets.difference(currentNegExamples, coveredNegExamples),
+ new TreeSet<Individual>(Sets.difference(currentPosExamples, uncoveredPosExamples)), uncoveredPosExamples,
+ coveredNegExamples, new TreeSet<Individual>(Sets.difference(currentNegExamples, coveredNegExamples)),
specifityScore, nrOfSpecificNodes);
// QueryTreeScore queryTreeScore = new QueryTreeScore(score, coverageScore,
@@ -400,8 +487,8 @@
* @param allTrees
* @return
*/
- private Set<QueryTree<String>> getUncoveredTrees(QueryTree<String> tree, List<QueryTree<String>> allTrees){
- Set<QueryTree<String>> uncoveredTrees = new LinkedHashSet<QueryTree<String>>();
+ private List<QueryTree<String>> getUncoveredTrees(QueryTree<String> tree, List<QueryTree<String>> allTrees){
+ List<QueryTree<String>> uncoveredTrees = new ArrayList<QueryTree<String>>();
for (QueryTree<String> queryTree : allTrees) {
boolean subsumed = queryTree.isSubsumedBy(tree);
if(!subsumed){
@@ -470,4 +557,33 @@
}
todoList.add(solution);
}
+
+ /**
+ * @param noisePercentage the noisePercentage to set
+ */
+ public void setNoisePercentage(double noisePercentage) {
+ this.noisePercentage = noisePercentage;
+ }
+
+ /**
+ * @param maxExecutionTimeInSeconds the maxExecutionTimeInSeconds to set
+ */
+ public void setMaxExecutionTimeInSeconds(int maxExecutionTimeInSeconds) {
+ this.maxExecutionTimeInSeconds = maxExecutionTimeInSeconds;
+ }
+
+ /**
+ * @param coverageBeta the coverageBeta to set
+ */
+ public void setCoverageBeta(double coverageBeta) {
+ this.coverageBeta = coverageBeta;
+ }
+
+ /* (non-Javadoc)
+ * @see java.lang.Object#clone()
+ */
+ @Override
+ public Object clone() throws CloneNotSupportedException {
+ return new QTL2Disjunctive(this);
+ }
}
Added: trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2DisjunctiveMT.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2DisjunctiveMT.java (rev 0)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2DisjunctiveMT.java 2014-05-07 13:43:54 UTC (rev 4262)
@@ -0,0 +1,559 @@
+package org.dllearner.algorithms.qtl;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.PriorityBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.log4j.Logger;
+import org.dllearner.algorithms.qtl.cache.QueryTreeCache;
+import org.dllearner.algorithms.qtl.datastructures.QueryTree;
+import org.dllearner.algorithms.qtl.datastructures.impl.QueryTreeImpl;
+import org.dllearner.algorithms.qtl.datastructures.impl.QueryTreeImpl.LiteralNodeConversionStrategy;
+import org.dllearner.algorithms.qtl.operations.lgg.EvaluatedQueryTree;
+import org.dllearner.algorithms.qtl.operations.lgg.LGGGenerator;
+import org.dllearner.algorithms.qtl.operations.lgg.LGGGeneratorImpl;
+import org.dllearner.core.AbstractCELA;
+import org.dllearner.core.AbstractReasonerComponent;
+import org.dllearner.core.ComponentAnn;
+import org.dllearner.core.ComponentInitException;
+import org.dllearner.core.EvaluatedDescription;
+import org.dllearner.core.KnowledgeSource;
+import org.dllearner.core.LearningProblemUnsupportedException;
+import org.dllearner.core.owl.Description;
+import org.dllearner.core.owl.Individual;
+import org.dllearner.kb.OWLFile;
+import org.dllearner.learningproblems.PosNegLP;
+import org.dllearner.learningproblems.QueryTreeScore;
+import org.dllearner.utilities.owl.DLLearnerDescriptionConvertVisitor;
+import org.dllearner.utilities.owl.OWLAPIConverter;
+import org.semanticweb.owlapi.io.ToStringRenderer;
+import org.semanticweb.owlapi.util.SimpleShortFormProvider;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import uk.ac.manchester.cs.owl.owlapi.mansyntaxrenderer.ManchesterOWLSyntaxOWLObjectRendererImpl;
+
+import com.google.common.collect.Sets;
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.rdf.model.ModelFactory;
+import com.jamonapi.Monitor;
+import com.jamonapi.MonitorFactory;
+
+@ComponentAnn(name="query tree learner with noise (disjunctive)", shortName="qtl2dis", version=0.8)
+public class QTL2DisjunctiveMT extends AbstractCELA {
+
+
+ private static final Logger logger = Logger.getLogger(QTL2DisjunctiveMT.class.getName());
+
+ private LGGGenerator<String> lggGenerator = new LGGGeneratorImpl<String>();
+
+ private BlockingQueue<EvaluatedQueryTree<String>> todoList;
+ private SortedSet<EvaluatedQueryTree<String>> solutions;
+
+ private double currentlyBestScore = 0d;
+
+ private List<QueryTree<String>> currentPosExampleTrees;
+ private List<QueryTree<String>> currentNegExampleTrees;
+
+ private Map<QueryTree<String>, Individual> tree2Indivual;
+
+ private double coverageWeight = 0.8;
+ private double specifityWeight = 0.2;
+
+ private QueryTreeCache treeCache;
+
+ private PosNegLP lp;
+
+ private Model model;
+
+ private AbstractReasonerComponent reasoner;
+
+ private volatile boolean stop;
+ private boolean isRunning;
+
+ private Monitor subMon;
+ private Monitor lggMon;
+
+ private final EvaluatedQueryTree<String> STOP_ELEMENT = new EvaluatedQueryTree<String>(new QueryTreeImpl<String>("STOP"), null, null, null);
+
+
+ public QTL2DisjunctiveMT() {}
+
+ public QTL2DisjunctiveMT(PosNegLP learningProblem, AbstractReasonerComponent reasoner) throws LearningProblemUnsupportedException{
+ this.lp = learningProblem;
+ this.reasoner = reasoner;
+
+ }
+
+ public QTL2DisjunctiveMT(PosNegLP lp, Model model) {
+ this.lp = lp;
+ this.model = model;
+ }
+
+ public EvaluatedQueryTree<String> getBestSolution(){
+ return solutions.first();
+ }
+
+ /* (non-Javadoc)
+ * @see org.dllearner.core.Component#init()
+ */
+ @Override
+ public void init() throws ComponentInitException {
+ logger.info("Initializing...");
+ treeCache = new QueryTreeCache(model);
+ tree2Indivual = new HashMap<QueryTree<String>, Individual>(lp.getPositiveExamples().size()+lp.getNegativeExamples().size());
+
+ currentPosExampleTrees = new ArrayList<QueryTree<String>>(lp.getPositiveExamples().size());
+ currentNegExampleTrees = new ArrayList<QueryTree<String>>(lp.getNegativeExamples().size());
+
+ //get the query trees
+ QueryTree<String> queryTree;
+ for (Individual ind : lp.getPositiveExamples()) {
+ queryTree = treeCache.getQueryTree(ind.getName());
+ tree2Indivual.put(queryTree, ind);
+ currentPosExampleTrees.add(queryTree);
+ }
+ for (Individual ind : lp.getNegativeExamples()) {
+ queryTree = treeCache.getQueryTree(ind.getName());
+ tree2Indivual.put(queryTree, ind);
+ currentNegExampleTrees.add(treeCache.getQueryTree(ind.getName()));
+ }
+
+ //some logging
+ subMon = MonitorFactory.getTimeMonitor("subsumption-mon");
+ lggMon = MonitorFactory.getTimeMonitor("lgg-mon");
+
+ //console rendering of class expressions
+ ToStringRenderer.getInstance().setRenderer(new ManchesterOWLSyntaxOWLObjectRendererImpl());
+ ToStringRenderer.getInstance().setShortFormProvider(new SimpleShortFormProvider());
+ }
+
+ /* (non-Javadoc)
+ * @see org.dllearner.core.LearningAlgorithm#start()
+ */
+ @Override
+ public void start() {
+ logger.info("Running...");
+ stop = false;
+ isRunning = true;
+ long startTime = System.currentTimeMillis();
+
+ subMon = MonitorFactory.getTimeMonitor("subsumption-mon");
+ lggMon = MonitorFactory.getTimeMonitor("lgg-mon");
+
+
+ //outer loop: compute LGG, pick best solution and remove all covered positive and negative examples
+ List<EvaluatedQueryTree<String>> unionSolutions = new ArrayList<EvaluatedQueryTree<String>>();
+ do {
+ //compute LGG
+ computeLGG();
+
+ //pick best solution computed so far
+ EvaluatedQueryTree<String> bestSolution = solutions.first();
+ unionSolutions.add(bestSolution);
+ logger.info("#Uncovered pos. examples:" + bestSolution.getFalseNegatives().size());
+
+ //remove all covered examples
+ QueryTree<String> tree;
+ for (Iterator<QueryTree<String>> iterator = currentPosExampleTrees.iterator(); iterator.hasNext();) {
+ tree = iterator.next();
+ if(tree.isSubsumedBy(bestSolution.getTree())){
+ iterator.remove();
+ }
+ }
+ for (Iterator<QueryTree<String>> iterator = currentNegExampleTrees.iterator(); iterator.hasNext();) {
+ tree = iterator.next();
+ if(tree.isSubsumedBy(bestSolution.getTree())){
+ iterator.remove();
+ }
+ }
+ } while (!(stop || currentPosExampleTrees.isEmpty()));
+
+
+ }
+
+ private void computeLGG(){
+ currentlyBestScore = 0d;
+ initTodoList(currentPosExampleTrees, currentNegExampleTrees);
+ long startTime = System.currentTimeMillis();
+ int nrOfThreads = Runtime.getRuntime().availableProcessors() - 1;
+ nrOfThreads = 2;
+ ExecutorService es = Executors.newFixedThreadPool(nrOfThreads);
+ for(int i = 0; i < nrOfThreads; i++){
+ es.submit(new QueryTreeProcessor());
+ }
+ es.shutdown();
+ try {
+ es.awaitTermination(1, TimeUnit.HOURS);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ long endTime = System.currentTimeMillis();
+ logger.info("Finished in " + (endTime-startTime) + "ms.");
+ EvaluatedDescription bestSolution = getCurrentlyBestEvaluatedDescription();
+ ToStringRenderer.getInstance().setRenderer(new ManchesterOWLSyntaxOWLObjectRendererImpl());
+ ToStringRenderer.getInstance().setShortFormProvider(new SimpleShortFormProvider());
+// solutions.first().getTree().dump();
+ logger.info("Best solution:\n" + OWLAPIConverter.getOWLAPIDescription(bestSolution.getDescription()) + "\n(" + bestSolution.getScore() + ")");
+
+ logger.trace("LGG time: " + lggMon.getTotal() + "ms");
+ logger.trace("Avg. LGG time: " + lggMon.getAvg() + "ms");
+ logger.trace("#LGG computations: " + lggMon.getHits());
+ logger.trace("Subsumption test time: " + subMon.getTotal() + "ms");
+ logger.trace("Avg. subsumption test time: " + subMon.getAvg() + "ms");
+ logger.trace("#Subsumption tests: " + subMon.getHits());
+ }
+
+ /* (non-Javadoc)
+ * @see org.dllearner.core.StoppableLearningAlgorithm#stop()
+ */
+ @Override
+ public void stop() {
+ stop = true;
+ }
+
+ /* (non-Javadoc)
+ * @see org.dllearner.core.AbstractCELA#getCurrentlyBestDescription()
+ */
+ @Override
+ public Description getCurrentlyBestDescription() {
+ return getCurrentlyBestEvaluatedDescription().getDescription();
+ }
+
+ /* (non-Javadoc)
+ * @see org.dllearner.core.AbstractCELA#getCurrentlyBestEvaluatedDescription()
+ */
+ @Override
+ public EvaluatedDescription getCurrentlyBestEvaluatedDescription() {
+ EvaluatedQueryTree<String> bestSolution = solutions.first();
+ Description description = DLLearnerDescriptionConvertVisitor.getDLLearnerDescription(
+ bestSolution.getTree().asOWLClassExpression(LiteralNodeConversionStrategy.FACET_RESTRICTION));
+ return new EvaluatedDescription(description, bestSolution.getTreeScore());
+ }
+
+ /* (non-Javadoc)
+ * @see org.dllearner.core.StoppableLearningAlgorithm#isRunning()
+ */
+ @Override
+ public boolean isRunning() {
+ return isRunning;
+ }
+
+ @Autowired
+ public void setLearningProblem(PosNegLP learningProblem) {
+ this.lp = learningProblem;
+ }
+
+ @Autowired
+ public void setReasoner(AbstractReasonerComponent reasoner){
+ this.reasoner = reasoner;
+ model = ModelFactory.createDefaultModel();
+ for (KnowledgeSource ks : reasoner.getSources()) {
+ if(ks instanceof OWLFile){
+ try {
+ model.read(((OWLFile) ks).getURL().openStream(), null);
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ }
+
+ /**
+ * @return the treeCache
+ */
+ public QueryTreeCache getTreeCache() {
+ return treeCache;
+ }
+
+ private EvaluatedQueryTree<String> evaluate(QueryTree<String> tree, boolean useSpecifity){
+ //1. get a score for the coverage = recall oriented
+ //compute positive examples which are not covered by LGG
+ Collection<QueryTree<String>> uncoveredPositiveExampleTrees = getUncoveredTrees(tree, currentPosExampleTrees);
+ Set<Individual> uncoveredPosExamples = new HashSet<Individual>();
+ for (QueryTree<String> queryTree : uncoveredPositiveExampleTrees) {
+ uncoveredPosExamples.add(tree2Indivual.get(queryTree));
+ }
+ //compute negative examples which are covered by LGG
+ Collection<QueryTree<String>> coveredNegativeExampleTrees = getCoveredTrees(tree, currentNegExampleTrees);
+ Set<Individual> coveredNegExamples = new HashSet<Individual>();
+ for (QueryTree<String> queryTree : coveredNegativeExampleTrees) {
+ coveredNegExamples.add(tree2Indivual.get(queryTree));
+ }
+ //compute score
+ int coveredPositiveExamples = currentPosExampleTrees.size() - uncoveredPositiveExampleTrees.size();
+ double recall = coveredPositiveExamples / (double)currentPosExampleTrees.size();
+ double precision = (coveredNegativeExampleTrees.size() + coveredPositiveExamples == 0)
+ ? 0
+ : coveredPositiveExamples / (double)(coveredPositiveExamples + coveredNegativeExampleTrees.size());
+
+ double coverageScore = recall;//Heuristics.getFScore(recall, precision);
+
+ //2. get a score for the specifity of the query, i.e. how many edges/nodes = precision oriented
+ int nrOfSpecificNodes = 0;
+ for (QueryTree<String> childNode : tree.getChildrenClosure()) {
+ if(!childNode.getUserObject().equals("?")){
+ nrOfSpecificNodes++;
+ }
+ }
+ double specifityScore = Math.log(nrOfSpecificNodes);
+
+ //3.compute the total score
+ double score = coverageWeight * coverageScore + specifityWeight * specifityScore;
+
+ QueryTreeScore queryTreeScore = new QueryTreeScore(score, coverageScore,
+ uncoveredPosExamples, Sets.difference(lp.getPositiveExamples(), uncoveredPosExamples),
+ coveredNegExamples, Sets.difference(lp.getNegativeExamples(), coveredNegExamples),
+ specifityScore, nrOfSpecificNodes);
+
+ EvaluatedQueryTree<String> evaluatedTree = new EvaluatedQueryTree<String>(tree, uncoveredPositiveExampleTrees, coveredNegativeExampleTrees, queryTreeScore);
+
+ return evaluatedTree;
+ }
+
+ /**
+ * Initializes the todo list with all distinct trees contained in the given list {@code trees}.
+ * Firstly, distinct trees are computed and afterwards, for each tree a score is computed.
+ * @param trees
+ */
+ private void initTodoList(List<QueryTree<String>> posExamples, List<QueryTree<String>> negExamples){
+ todoList = new PriorityBlockingQueue<EvaluatedQueryTree<String>>();
+ solutions = new TreeSet<EvaluatedQueryTree<String>>();
+// EvaluatedQueryTree<String> dummy = new EvaluatedQueryTree<String>(new QueryTreeImpl<String>((N)"TOP"), trees, 0d);
+// todoList.add(dummy);
+ //compute distinct trees
+ Collection<QueryTree<String>> distinctTrees = new ArrayList<QueryTree<String>>();
+ for (QueryTree<String> queryTree : posExamples) {
+ boolean distinct = true;
+ for (QueryTree<String> otherTree : distinctTrees) {
+ if(!queryTree.equals(otherTree)){
+ if(queryTree.isSameTreeAs(otherTree)){
+ distinct = false;
+ break;
+ }
+ }
+ }
+ if(distinct){
+ distinctTrees.add(queryTree);
+ }
+ }
+ for (QueryTree<String> queryTree : distinctTrees) {//System.out.println(queryTree.getStringRepresentation());
+ EvaluatedQueryTree<String> evaluatedQueryTree = evaluate(queryTree, false);
+ todoList.add(evaluatedQueryTree);
+ }
+ }
+
+ /**
+ * Return all trees from the given list {@code allTrees} which are not already subsumed by {@code tree}.
+ * @param tree
+ * @param allTrees
+ * @return
+ */
+ private Collection<QueryTree<String>> getCoveredTrees(QueryTree<String> tree, List<QueryTree<String>> trees){
+ Collection<QueryTree<String>> coveredTrees = new ArrayList<QueryTree<String>>();
+ for (QueryTree<String> queryTree : trees) {
+ boolean subsumed = queryTree.isSubsumedBy(tree);
+ if(subsumed){
+ coveredTrees.add(queryTree);
+ }
+ }
+ return coveredTrees;
+ }
+
+ /**
+ * Return all trees from the given list {@code allTrees} which are not already subsumed by {@code tree}.
+ * @param tree
+ * @param allTrees
+ * @return
+ */
+ private Collection<QueryTree<String>> getUncoveredTrees(QueryTree<String> tree, List<QueryTree<String>> allTrees){
+ Collection<QueryTree<String>> uncoveredTrees = new ArrayList<QueryTree<String>>();
+ for (QueryTree<String> queryTree : allTrees) {
+ boolean subsumed = queryTree.isSubsumedBy(tree);
+ if(!subsumed){
+ uncoveredTrees.add(queryTree);
+ }
+ }
+ return uncoveredTrees;
+ }
+
+ private boolean sameTrees(QueryTree<String> tree1, QueryTree<String> tree2){
+ return tree1.isSubsumedBy(tree2) && tree2.isSubsumedBy(tree1);
+ }
+
+ private synchronized boolean terminationCriteriaSatisfied(){
+ return stop || todoList.isEmpty() || currentPosExampleTrees.isEmpty();
+ }
+
+ /**
+ * Add tree to todo list if not already contained in that list or the solutions.
+ * @param solution
+ */
+ private void todo(EvaluatedQueryTree<String> solution){
+ //check if not already contained in todo list
+ for (EvaluatedQueryTree<String> evTree : todoList) {
+ if(sameTrees(solution.getTree(), evTree.getTree())){
+ return;
+ }
+ }
+ //check if not already contained in solutions
+ for (EvaluatedQueryTree<String> evTree : solutions) {
+ if(sameTrees(solution.getTree(), evTree.getTree())){
+ return;
+ }
+ }
+ try {
+ todoList.put(solution);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+
+ class QueryTreeProcessor implements Runnable {
+
+ volatile boolean isRunning;
+ LGGGenerator<String> lggGenerator = new LGGGeneratorImpl<String>();
+
+ /**
+ *
+ */
+ public QueryTreeProcessor() {
+ }
+
+ /* (non-Javadoc)
+ * @see java.lang.Runnable#run()
+ */
+ @Override
+ public void run() {
+ long startTime = System.currentTimeMillis();
+ while(!terminationCriteriaSatisfied()){
+ double currentlyBestScore = 0d;
+ try {
+ long t1 = System.currentTimeMillis();
+ EvaluatedQueryTree<String> evaluatedQueryTree = todoList.take();
+ long t2 = System.currentTimeMillis();
+ System.out.println(Thread.currentThread().getId() + "\t waiting time:" + (t2-t1));
+ for (QueryTree<String> example : evaluatedQueryTree.getFalseNegatives()) {
+ //compute the LGG
+// lggMon.start();
+ QueryTree<String> lgg = lggGenerator.getLGG(evaluatedQueryTree.getTree(), example);
+// lggMon.stop();
+
+ //evaluate the LGG
+ EvaluatedQueryTree<String> solution = evaluate(lgg, true);
+
+ if(solution.getScore() >= currentlyBestScore){
+ //add to todo list, if not already contained in todo list or solution list
+ todo(solution);
+ if(solution.getScore() > currentlyBestScore){
+ logger.info("Got better solution:" + solution.getTreeScore());
+ }
+ currentlyBestScore = solution.getScore();
+ }
+ }
+ long t3 = System.currentTimeMillis();
+ System.out.println(Thread.currentThread().getId() + "\t processing time:" + (t3-t2));
+ // add currently processed tree to solutions
+ solutions.add(evaluatedQueryTree);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ System.out.println(System.currentTimeMillis() + ":" + Thread.currentThread().getId() + " finished");
+ }
+
+ private EvaluatedQueryTree<String> evaluate(QueryTree<String> tree, boolean useSpecifity){
+ //1. get a score for the coverage = recall oriented
+ //compute positive examples which are not covered by LGG
+ Collection<QueryTree<String>> uncoveredPositiveExampleTrees = getUncoveredTrees(tree, currentPosExampleTrees);
+ Set<Individual> uncoveredPosExamples = new HashSet<Individual>();
+ for (QueryTree<String> queryTree : uncoveredPositiveExampleTrees) {
+ uncoveredPosExamples.add(tree2Indivual.get(queryTree));
+ }
+ //compute negative examples which are covered by LGG
+ Collection<QueryTree<String>> coveredNegativeExampleTrees = getCoveredTrees(tree, currentNegExampleTrees);
+ Set<Individual> coveredNegExamples = new HashSet<Individual>();
+ for (QueryTree<String> queryTree : coveredNegativeExampleTrees) {
+ coveredNegExamples.add(tree2Indivual.get(queryTree));
+ }
+ //compute score
+ int coveredPositiveExamples = currentPosExampleTrees.size() - uncoveredPositiveExampleTrees.size();
+ double recall = coveredPositiveExamples / (double)currentPosExampleTrees.size();
+ double precision = (coveredNegativeExampleTrees.size() + coveredPositiveExamples == 0)
+ ? 0
+ : coveredPositiveExamples / (double)(coveredPositiveExamples + coveredNegativeExampleTrees.size());
+
+ double coverageScore = recall;//Heuristics.getFScore(recall, precision);
+
+ //2. get a score for the specifity of the query, i.e. how many edges/nodes = precision oriented
+ int nrOfSpecificNodes = 0;
+ for (QueryTree<String> childNode : tree.getChildrenClosure()) {
+ if(!childNode.getUserObject().equals("?")){
+ nrOfSpecificNodes++;
+ }
+ }
+ double specifityScore = Math.log(nrOfSpecificNodes);
+
+ //3.compute the total score
+ double score = coverageWeight * coverageScore + specifityWeight * specifityScore;
+
+ QueryTreeScore queryTreeScore = new QueryTreeScore(score, coverageScore,
+ uncoveredPosExamples, Sets.difference(lp.getPositiveExamples(), uncoveredPosExamples),
+ coveredNegExamples, Sets.difference(lp.getNegativeExamples(), coveredNegExamples),
+ specifityScore, nrOfSpecificNodes);
+
+ EvaluatedQueryTree<String> evaluatedTree = new EvaluatedQueryTree<String>(tree, uncoveredPositiveExampleTrees, coveredNegativeExampleTrees, queryTreeScore);
+
+ return evaluatedTree;
+ }
+
+ /**
+ * Return all trees from the given list {@code allTrees} which are not already subsumed by {@code tree}.
+ * @param tree
+ * @param allTrees
+ * @return
+ */
+ private Collection<QueryTree<String>> getCoveredTrees(QueryTree<String> tree, List<QueryTree<String>> trees){
+ Collection<QueryTree<String>> coveredTrees = new ArrayList<QueryTree<String>>();
+ for (QueryTree<String> queryTree : trees) {
+ boolean subsumed = queryTree.isSubsumedBy(tree);
+ if(subsumed){
+ coveredTrees.add(queryTree);
+ }
+ }
+ return coveredTrees;
+ }
+
+ /**
+ * Return all trees from the given list {@code allTrees} which are not already subsumed by {@code tree}.
+ * @param tree
+ * @param allTrees
+ * @return
+ */
+ private Collection<QueryTree<String>> getUncoveredTrees(QueryTree<String> tree, List<QueryTree<String>> allTrees){
+ Collection<QueryTree<String>> uncoveredTrees = new ArrayList<QueryTree<String>>();
+ for (QueryTree<String> queryTree : allTrees) {
+ boolean subsumed = queryTree.isSubsumedBy(tree);
+ if(!subsumed){
+ uncoveredTrees.add(queryTree);
+ }
+ }
+ return uncoveredTrees;
+ }
+
+ }
+
+}
Added: trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QueryTreeHeuristic.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QueryTreeHeuristic.java (rev 0)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QueryTreeHeuristic.java 2014-05-07 13:43:54 UTC (rev 4262)
@@ -0,0 +1,79 @@
+/**
+ *
+ */
+package org.dllearner.algorithms.qtl;
+
+import java.util.Comparator;
+import java.util.Set;
+
+import org.dllearner.algorithms.qtl.operations.lgg.EvaluatedQueryTree;
+import org.dllearner.core.AbstractComponent;
+import org.dllearner.core.ComponentAnn;
+import org.dllearner.core.ComponentInitException;
+import org.dllearner.core.Heuristic;
+import org.dllearner.core.owl.Individual;
+import org.dllearner.learningproblems.Heuristics;
+import org.dllearner.learningproblems.QueryTreeScore;
+import org.dllearner.utilities.owl.ConceptComparator;
+
+/**
+ * @author Lorenz Buehmann
+ *
+ */
+@ComponentAnn(name = "QueryTreeHeuristic", shortName = "qtree_heuristic", version = 0.1)
+public class QueryTreeHeuristic extends AbstractComponent implements Heuristic, Comparator<EvaluatedQueryTree<String>>{
+
+ // F score beta value
+ private double coverageBeta = 1;
+
+ private double coverageWeight = 0.8;
+
+ private double specifityWeight = 0.1;
+
+ // syntactic comparison as final comparison criterion
+ private ConceptComparator conceptComparator = new ConceptComparator();
+
+ /* (non-Javadoc)
+ * @see org.dllearner.core.Component#init()
+ */
+ @Override
+ public void init() throws ComponentInitException {
+ }
+
+ public double getScore(EvaluatedQueryTree<String> tree){
+ QueryTreeScore treeScore = tree.getTreeScore();
+
+ //TODO
+ double score = treeScore.getScore();
+
+ return score;
+ }
+
+ private double getPredictedAccuracy(EvaluatedQueryTree<String> tree){
+ QueryTreeScore treeScore = tree.getTreeScore();
+
+ Set<Individual> truePositives = treeScore.getCoveredPositives();
+ Set<Individual> trueNegatives = treeScore.getNotCoveredNegatives();
+ Set<Individual> falsePositives = treeScore.getNotCoveredPositives();
+ Set<Individual> falseNegatives = treeScore.getCoveredNegatives();
+ return 0;
+
+ }
+
+ /* (non-Javadoc)
+ * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
+ */
+ @Override
+ public int compare(EvaluatedQueryTree<String> tree1, EvaluatedQueryTree<String> tree2) {
+ double diff = getScore(tree1) - getScore(tree2);
+
+ if (diff > 0) {
+ return 1;
+ } else if (diff < 0) {
+ return -1;
+ } else {
+ return conceptComparator.compare(tree1.asEvaluatedDescription().getDescription(), tree2.asEvaluatedDescription().getDescription());
+ }
+ }
+
+}
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/datastructures/impl/QueryTreeImpl.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/datastructures/impl/QueryTreeImpl.java 2014-05-07 11:25:54 UTC (rev 4261)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/datastructures/impl/QueryTreeImpl.java 2014-05-07 13:43:54 UTC (rev 4262)
@@ -1488,7 +1488,7 @@
private String prefixed(Map<String, String> prefixes, String uri){
if(uri.startsWith("http://")){
- for (Entry<String, String> entry : prefixes.entrySet()) {System.out.println(entry);
+ for (Entry<String, String> entry : prefixes.entrySet()) {
String prefix = entry.getKey();
String ns = entry.getValue();
if(uri.startsWith(ns)){
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/impl/QueryTre...
[truncated message content] |
