Menu
▾
▴
[DL-Learner SVN] SF.net SVN: dl-learner:[4280] trunk
|
From: <lor...@us...> - 2014-07-29 13:53:27
|
Revision: 4280
http://sourceforge.net/p/dl-learner/code/4280
Author: lorenz_b
Date: 2014-07-29 13:53:19 +0000 (Tue, 29 Jul 2014)
Log Message:
-----------
Added punning test.
Modified Paths:
--------------
trunk/components-core/pom.xml
trunk/components-core/src/main/java/org/dllearner/algorithms/celoe/CELOE.java
trunk/components-core/src/main/java/org/dllearner/algorithms/celoe/OENode.java
trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2.java
trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2Disjunctive.java
trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2DisjunctiveMT.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/operations/lgg/EvaluatedQueryTree.java
trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/util/QueryTreeConverter.java
trunk/components-core/src/main/java/org/dllearner/core/AbstractCELA.java
trunk/components-core/src/main/java/org/dllearner/core/owl/Constant.java
trunk/components-core/src/main/java/org/dllearner/core/owl/DatatypeProperty.java
trunk/components-core/src/main/java/org/dllearner/core/owl/DoubleMaxValue.java
trunk/components-core/src/main/java/org/dllearner/core/owl/DoubleMinMaxRange.java
trunk/components-core/src/main/java/org/dllearner/core/owl/DoubleMinValue.java
trunk/components-core/src/main/java/org/dllearner/core/owl/ObjectProperty.java
trunk/components-core/src/main/java/org/dllearner/core/owl/TypedConstant.java
trunk/components-core/src/main/java/org/dllearner/reasoning/ExistentialRestrictionMaterialization.java
trunk/components-core/src/main/java/org/dllearner/reasoning/FastInstanceChecker.java
trunk/components-core/src/main/java/org/dllearner/reasoning/MaterializableFastInstanceChecker.java
trunk/components-core/src/main/java/org/dllearner/reasoning/OWLAPIReasoner.java
trunk/components-core/src/main/java/org/dllearner/refinementoperators/RhoDRDown.java
trunk/components-core/src/main/java/org/dllearner/utilities/owl/ConceptComparator.java
trunk/components-core/src/main/java/org/dllearner/utilities/owl/OWLAPIDescriptionConvertVisitor.java
trunk/components-core/src/main/java/org/dllearner/utilities/owl/RoleComparator.java
trunk/components-core/src/test/java/org/dllearner/algorithms/isle/ISLETestCorpus.java
trunk/components-core/src/test/java/org/dllearner/algorithms/isle/ISLETestNoCorpus.java
trunk/components-core/src/test/java/org/dllearner/algorithms/isle/metrics/PMIRelevanceMetricTest.java
trunk/components-core/src/test/java/org/dllearner/algorithms/isle/metrics/RelevanceMetricsTest.java
trunk/components-core/src/test/java/org/dllearner/algorithms/pattern/OWLPatternDetectionTest.java
trunk/components-core/src/test/java/org/dllearner/algorithms/qtl/GeneralisationTest.java
trunk/components-core/src/test/java/org/dllearner/algorithms/qtl/LGGTest.java
trunk/components-core/src/test/java/org/dllearner/algorithms/qtl/QTLTest.java
trunk/components-core/src/test/java/org/dllearner/test/junit/SomeOnlyReasonerTest.java
trunk/interfaces/pom.xml
trunk/interfaces/src/main/java/org/dllearner/cli/CLI.java
trunk/pom.xml
trunk/scripts/pom.xml
trunk/scripts/src/main/java/org/dllearner/scripts/RAChallenge.java
trunk/scripts/src/main/java/org/dllearner/scripts/evaluation/QTLEvaluation.java
trunk/scripts/src/main/java/org/dllearner/scripts/pattern/OWLAxiomPatternUsageEvaluation.java
Modified: trunk/components-core/pom.xml
===================================================================
--- trunk/components-core/pom.xml 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/pom.xml 2014-07-29 13:53:19 UTC (rev 4280)
@@ -100,10 +100,10 @@
<artifactId>mysql-connector-java</artifactId>
</dependency>
- <dependency>
+ <!-- <dependency>
<groupId>net.sourceforge.owlapi</groupId>
<artifactId>owlapi-distribution</artifactId>
- </dependency>
+ </dependency> -->
<dependency>
<groupId>com.clarkparsia</groupId>
@@ -152,10 +152,6 @@
<artifactId>hermit</artifactId>
</dependency>
- <dependency>
- <groupId>eu.trowl</groupId>
- <artifactId>trowl-core</artifactId>
- </dependency>
<dependency>
<groupId>com.jamonapi</groupId>
@@ -249,6 +245,11 @@
<artifactId>jsexp</artifactId>
<version>0.1.0</version>
</dependency>
+ <dependency>
+ <groupId>eu.trowl</groupId>
+ <artifactId>trowl-core</artifactId>
+ <version>1.4.0</version>
+ </dependency>
<dependency>
<groupId>xerces</groupId>
@@ -334,6 +335,16 @@
<artifactId>solr-solrj</artifactId>
<version>4.4.0</version>
</dependency>
+ <dependency>
+ <groupId>nz.ac.waikato.cms.weka</groupId>
+ <artifactId>weka-dev</artifactId>
+ <version>3.7.11</version>
+</dependency>
+ <!-- <dependency>
+ <groupId>nz.ac.waikato.cms.weka</groupId>
+ <artifactId>weka-stable</artifactId>
+ <version>3.6.9</version>
+ </dependency> -->
</dependencies>
<dependencyManagement>
<dependencies>
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/celoe/CELOE.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/celoe/CELOE.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/celoe/CELOE.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -32,7 +32,6 @@
import java.util.TreeSet;
import org.apache.log4j.Logger;
-import org.dllearner.algorithms.elcopy.ELLearningAlgorithm;
import org.dllearner.core.AbstractCELA;
import org.dllearner.core.AbstractHeuristic;
import org.dllearner.core.AbstractKnowledgeSource;
@@ -50,7 +49,6 @@
import org.dllearner.core.owl.Restriction;
import org.dllearner.core.owl.Thing;
import org.dllearner.kb.OWLAPIOntology;
-import org.dllearner.kb.OWLFile;
import org.dllearner.learningproblems.ClassLearningProblem;
import org.dllearner.learningproblems.PosNegLP;
import org.dllearner.learningproblems.PosOnlyLP;
@@ -92,7 +90,7 @@
*
*/
@ComponentAnn(name="CELOE", shortName="celoe", version=1.0, description="CELOE is an adapted and extended version of the OCEL algorithm applied for the ontology engineering use case. See http://jens-lehmann.org/files/2011/celoe.pdf for reference.")
-public class CELOE extends AbstractCELA {
+public class CELOE extends AbstractCELA implements Cloneable{
private static Logger logger = Logger.getLogger(CELOE.class);
// private CELOEConfigurator configurator;
@@ -224,6 +222,39 @@
}
+ public CELOE(CELOE celoe){
+ setReasoner(celoe.reasoner);
+ setLearningProblem(celoe.learningProblem);
+ setAllowedConcepts(celoe.getAllowedConcepts());
+ setExpandAccuracy100Nodes(celoe.expandAccuracy100Nodes);
+ setFilterDescriptionsFollowingFromKB(celoe.filterDescriptionsFollowingFromKB);
+ setHeuristic(celoe.heuristic);
+ setIgnoredConcepts(celoe.ignoredConcepts);
+ setLearningProblem(celoe.learningProblem);
+ setMaxClassExpressionTests(celoe.maxClassExpressionTests);
+ setMaxClassExpressionTestsAfterImprovement(celoe.maxClassExpressionTestsAfterImprovement);
+ setMaxDepth(celoe.maxDepth);
+ setMaxExecutionTimeInSeconds(celoe.maxExecutionTimeInSeconds);
+ setMaxExecutionTimeInSecondsAfterImprovement(celoe.maxExecutionTimeInSecondsAfterImprovement);
+ setMaxNrOfResults(celoe.maxNrOfResults);
+ setNoisePercentage(celoe.noisePercentage);
+ RhoDRDown op = new RhoDRDown((RhoDRDown)celoe.operator);
+ try {
+ op.init();
+ } catch (ComponentInitException e) {
+ e.printStackTrace();
+ }
+ setOperator(op);
+ setReplaceSearchTree(celoe.replaceSearchTree);
+ setReuseExistingDescription(celoe.reuseExistingDescription);
+ setSingleSuggestionMode(celoe.singleSuggestionMode);
+ setStartClass(celoe.startClass);
+ setStopOnFirstDefinition(celoe.stopOnFirstDefinition);
+ setTerminateOnNoiseReached(celoe.terminateOnNoiseReached);
+ setUseMinimizer(celoe.useMinimizer);
+ setWriteSearchTree(celoe.writeSearchTree);
+ }
+
public CELOE(AbstractLearningProblem problem, AbstractReasonerComponent reasoner) {
super(problem, reasoner);
// configurator = new CELOEConfigurator(this);
@@ -529,7 +560,7 @@
treeString += " " + n + "\n";
}
}
- treeString += startNode.toTreeString(baseURI);
+ treeString += startNode.toTreeString(baseURI, prefixes);
treeString += "\n";
if (replaceSearchTree)
@@ -1134,6 +1165,14 @@
public void setExpandAccuracy100Nodes(boolean expandAccuracy100Nodes) {
this.expandAccuracy100Nodes = expandAccuracy100Nodes;
}
+
+ /* (non-Javadoc)
+ * @see java.lang.Object#clone()
+ */
+ @Override
+ public Object clone() throws CloneNotSupportedException {
+ return new CELOE(this);
+ }
public static void main(String[] args) throws Exception{
String cls = "http://purl.org/procurement/public-contracts#Tender";
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/celoe/OENode.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/celoe/OENode.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/celoe/OENode.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -22,6 +22,7 @@
import java.text.DecimalFormat;
import java.util.LinkedList;
import java.util.List;
+import java.util.Map;
import org.dllearner.algorithms.SearchTreeNode;
import org.dllearner.algorithms.isle.NLPHeuristic;
@@ -119,7 +120,11 @@
}
public String getShortDescription(String baseURI) {
- String ret = description.toString(baseURI,null) + " [";
+ return getShortDescription(baseURI, null);
+ }
+
+ public String getShortDescription(String baseURI, Map<String, String> prefixes) {
+ String ret = description.toString(baseURI,prefixes) + " [";
// ret += "score" + NLPHeuristic.getNodeScore(this) + ",";
ret += "acc:" + dfPercent.format(accuracy) + ", ";
ret += "he:" + horizontalExpansion + ", ";
@@ -141,6 +146,10 @@
return toTreeString(0, baseURI).toString();
}
+ public String toTreeString(String baseURI, Map<String, String> prefixes) {
+ return toTreeString(0, baseURI, prefixes).toString();
+ }
+
private StringBuilder toTreeString(int depth, String baseURI) {
StringBuilder treeString = new StringBuilder();
for(int i=0; i<depth-1; i++)
@@ -153,6 +162,19 @@
}
return treeString;
}
+
+ private StringBuilder toTreeString(int depth, String baseURI, Map<String, String> prefixes) {
+ StringBuilder treeString = new StringBuilder();
+ for(int i=0; i<depth-1; i++)
+ treeString.append(" ");
+ if(depth!=0)
+ treeString.append("|--> ");
+ treeString.append(getShortDescription(baseURI, prefixes)+"\n");
+ for(OENode child : children) {
+ treeString.append(child.toTreeString(depth+1,baseURI,prefixes));
+ }
+ return treeString;
+ }
/**
* @return the refinementCount
@@ -166,5 +188,5 @@
*/
public void setRefinementCount(int refinementCount) {
this.refinementCount = refinementCount;
- }
+ }
}
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -202,7 +202,7 @@
public EvaluatedDescription getCurrentlyBestEvaluatedDescription() {
EvaluatedQueryTree<String> bestSolution = solutions.first();
Description description = DLLearnerDescriptionConvertVisitor.getDLLearnerDescription(
- bestSolution.getTree().asOWLClassExpression(LiteralNodeConversionStrategy.FACET_RESTRICTION));
+ bestSolution.getTree().asOWLClassExpression(LiteralNodeConversionStrategy.MIN_MAX));
return new EvaluatedDescription(description, new AxiomScore(bestSolution.getScore()));
}
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-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2Disjunctive.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -19,7 +19,6 @@
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.datastructures.impl.QueryTreeImpl.LiteralNodeSubsumptionStrategy;
import org.dllearner.algorithms.qtl.operations.lgg.EvaluatedQueryTree;
@@ -42,8 +41,10 @@
import org.dllearner.learningproblems.PosNegLP;
import org.dllearner.learningproblems.QueryTreeScore;
import org.dllearner.utilities.owl.DLLearnerDescriptionConvertVisitor;
+import org.dllearner.utilities.owl.DLSyntaxObjectRenderer;
import org.dllearner.utilities.owl.OWLAPIConverter;
import org.semanticweb.owlapi.io.ToStringRenderer;
+import org.semanticweb.owlapi.model.OWLClassExpression;
import org.semanticweb.owlapi.util.SimpleShortFormProvider;
import org.springframework.beans.factory.annotation.Autowired;
@@ -75,6 +76,7 @@
private Set<Individual> currentNegExamples;
private Map<QueryTree<String>, Individual> tree2Individual;
+ private Map<Individual, QueryTree<String>> individual2Tree;
private QueryTreeCache treeCache;
@@ -121,7 +123,15 @@
private long partialSolutionStartTime;
private double startPosExamplesSize;
+ private int expressionTests = 0;
+ LiteralNodeConversionStrategy[] strategies = new LiteralNodeConversionStrategy[]{
+ LiteralNodeConversionStrategy.MIN,
+ LiteralNodeConversionStrategy.MAX,
+ LiteralNodeConversionStrategy.MIN_MAX,
+ LiteralNodeConversionStrategy.DATATYPE
+ };
+
public QTL2Disjunctive() {}
public QTL2Disjunctive(PosNegLP learningProblem, AbstractReasonerComponent reasoner) throws LearningProblemUnsupportedException{
@@ -154,7 +164,7 @@
*/
@Override
public void init() throws ComponentInitException {
-
+ ToStringRenderer.getInstance().setRenderer(new DLSyntaxObjectRenderer());
if(!(learningProblem instanceof PosNegLP)){
throw new IllegalArgumentException("Only PosNeg learning problems are supported");
}
@@ -170,6 +180,7 @@
logger.info("Initializing...");
treeCache = new QueryTreeCache(model);
tree2Individual = new HashMap<QueryTree<String>, Individual>(lp.getPositiveExamples().size()+lp.getNegativeExamples().size());
+ individual2Tree = new HashMap<Individual, QueryTree<String>>(lp.getPositiveExamples().size()+lp.getNegativeExamples().size());
currentPosExampleTrees = new ArrayList<QueryTree<String>>(lp.getPositiveExamples().size());
currentNegExampleTrees = new ArrayList<QueryTree<String>>(lp.getNegativeExamples().size());
@@ -205,11 +216,13 @@
for (Individual ind : lp.getPositiveExamples()) {
queryTree = treeCache.getQueryTree(ind.getName());
tree2Individual.put(queryTree, ind);
+ individual2Tree.put(ind, queryTree);
currentPosExampleTrees.add(queryTree);
}
for (Individual ind : lp.getNegativeExamples()) {
queryTree = treeCache.getQueryTree(ind.getName());
tree2Individual.put(queryTree, ind);
+ individual2Tree.put(ind, queryTree);
currentNegExampleTrees.add(queryTree);
}
logger.info("...done.");
@@ -235,7 +248,7 @@
//compute best (partial) solution computed so far
EvaluatedQueryTree<String> bestPartialSolution = computeBestPartialSolution();
- //add if some criteria are satisfied
+ //add to partial solutions if criteria are satisfied
if(bestPartialSolution.getScore() >= minimumTreeScore){
partialSolutions.add(bestPartialSolution);
@@ -244,14 +257,14 @@
QueryTree<String> tree;
for (Iterator<QueryTree<String>> iterator = currentPosExampleTrees.iterator(); iterator.hasNext();) {
tree = iterator.next();
- if(tree.isSubsumedBy(bestPartialSolution.getTree())){
+ if(!bestPartialSolution.getFalseNegatives().contains(tree)){//a pos tree that is not covered
iterator.remove();
currentPosExamples.remove(tree2Individual.get(tree));
}
}
for (Iterator<QueryTree<String>> iterator = currentNegExampleTrees.iterator(); iterator.hasNext();) {
tree = iterator.next();
- if(tree.isSubsumedBy(bestPartialSolution.getTree())){
+ if(bestPartialSolution.getFalsePositives().contains(tree)){//a neg example that is covered
iterator.remove();
currentNegExamples.remove(tree2Individual.get(tree));
}
@@ -272,8 +285,9 @@
long endTime = System.currentTimeMillis();
logger.info("Finished in " + (endTime-startTime) + "ms.");
+ logger.info(expressionTests +" descriptions tested");
+ logger.info("Combined solution:" + OWLAPIConverter.getOWLAPIDescription(currentBestSolution.getDescription()).toString().replace("\n", ""));
- logger.info("Combined solution:" + OWLAPIConverter.getOWLAPIDescription(currentBestSolution.getDescription()).toString().replace("\n", ""));
logger.info(currentBestSolution.getScore());
}
@@ -291,7 +305,9 @@
logger.trace("TODO list size: " + todoList.size());
//pick best element from todo list
currentElement = todoList.poll();
+
currentTree = currentElement.getTree();
+ logger.info("Next tree: " + currentElement.getTreeScore() + "\n" + OWLAPIConverter.getOWLAPIDescription(currentElement.getEvaluatedDescription().getDescription()));
//generate the LGG between the chosen tree and each uncovered positive example
Iterator<QueryTree<String>> it = currentElement.getFalseNegatives().iterator();
while (it.hasNext() && !isPartialSolutionTimeExpired() && !isTimeExpired()) {
@@ -302,26 +318,29 @@
lggMon.stop();
//evaluate the LGG
- Set<EvaluatedQueryTree<String>> solutions = evaluate(lgg, true);
+ Set<EvaluatedQueryTree<String>> solutions = evaluate2(lgg, true);
for (EvaluatedQueryTree<String> solution : solutions) {
+ expressionTests++;
double score = solution.getScore();
double mas = heuristic.getMaximumAchievableScore(solution);
if(score >= bestCurrentScore){
- //add to todo list, if not already contained in todo list or solution list
- todo(solution);
if(score > bestCurrentScore){
logger.info("\tGot better solution:" + solution.getTreeScore());
+ logger.info(OWLAPIConverter.getOWLAPIDescription(solution.getEvaluatedDescription().getDescription()));
bestCurrentScore = score;
bestPartialSolutionTree = solution;
}
-
+ //add to todo list, if not already contained in todo list or solution list
+ todo(solution);
} else if(mas >= bestCurrentScore){
todo(solution);
} else {
+ logger.info("Too weak:" + solution.getTreeScore());
// System.out.println("Too general");
// System.out.println("MAS=" + mas + "\nBest=" + bestCurrentScore);
}
+
currentPartialSolutions.add(currentElement);
}
}
@@ -329,7 +348,7 @@
}
long endTime = System.currentTimeMillis();
logger.info("...finished in " + (endTime-partialSolutionStartTime) + "ms.");
- EvaluatedDescription bestPartialSolution = bestPartialSolutionTree.asEvaluatedDescription(LiteralNodeConversionStrategy.SOME_VALUES_FROM);
+ EvaluatedDescription bestPartialSolution = bestPartialSolutionTree.getEvaluatedDescription();
logger.info("Best partial solution: " + OWLAPIConverter.getOWLAPIDescription(bestPartialSolution.getDescription()).toString().replace("\n", "") + "\n(" + bestPartialSolution.getScore() + ")");
@@ -410,7 +429,12 @@
Set<EvaluatedQueryTree<String>> evaluatedTrees = new TreeSet<EvaluatedQueryTree<String>>();
LiteralNodeSubsumptionStrategy[] strategies = LiteralNodeSubsumptionStrategy.values();
- strategies = new LiteralNodeSubsumptionStrategy[]{LiteralNodeSubsumptionStrategy.DATATYPE, LiteralNodeSubsumptionStrategy.INTERVAL};
+ strategies = new LiteralNodeSubsumptionStrategy[]{
+ LiteralNodeSubsumptionStrategy.DATATYPE,
+ LiteralNodeSubsumptionStrategy.INTERVAL,
+ LiteralNodeSubsumptionStrategy.MIN,
+ LiteralNodeSubsumptionStrategy.MAX,
+ };
for (LiteralNodeSubsumptionStrategy strategy : strategies) {
//1. get a score for the coverage = recall oriented
List<QueryTree<String>> uncoveredPositiveExampleTrees = new ArrayList<QueryTree<String>>();
@@ -480,18 +504,27 @@
* @param useSpecifity
* @return
*/
- private Set<EvaluatedDescription> evaluate2(QueryTree<String> tree, boolean useSpecifity){
- Set<EvaluatedDescription> evaluatedDescriptions = new TreeSet<EvaluatedDescription>();
+ private Set<EvaluatedQueryTree<String>> evaluate2(QueryTree<String> tree, boolean useSpecifity){
+ Set<EvaluatedQueryTree<String>> evaluatedTrees = new TreeSet<EvaluatedQueryTree<String>>();
- LiteralNodeConversionStrategy[] strategies = LiteralNodeConversionStrategy.values();
- strategies = new LiteralNodeConversionStrategy[]{LiteralNodeConversionStrategy.SOME_VALUES_FROM, LiteralNodeConversionStrategy.FACET_RESTRICTION};
+ //test different strategies on the conversion of literal nodes
+ Set<OWLClassExpression> combinations = new HashSet<OWLClassExpression>();
+
for (LiteralNodeConversionStrategy strategy : strategies) {
- Description d = DLLearnerDescriptionConvertVisitor.getDLLearnerDescription(tree.asOWLClassExpression(strategy));
+ OWLClassExpression ce = tree.asOWLClassExpression(strategy);
+ combinations.add(ce);
+ }
+ //compute all combinations of different types of facets
+// OWLClassExpression ce = tree.asOWLClassExpression(LiteralNodeConversionStrategy.FACET_RESTRICTION);
+// combinations = ce.accept(new ClassExpressionLiteralCombination());
+ for (OWLClassExpression c : combinations) {
+ Description d = DLLearnerDescriptionConvertVisitor.getDLLearnerDescription(c);
//convert to individuals
SortedSet<Individual> coveredExamples = reasoner.getIndividuals(d);
Set<Individual> coveredPosExamples = new TreeSet<Individual>(Sets.intersection(currentPosExamples, coveredExamples));
Set<Individual> uncoveredPosExamples = new TreeSet<Individual>(Sets.difference(currentPosExamples, coveredExamples));
Set<Individual> coveredNegExamples = new TreeSet<Individual>(Sets.intersection(currentNegExamples, coveredExamples));
+ Set<Individual> uncoveredNegExamples = new TreeSet<Individual>(Sets.difference(currentNegExamples, coveredExamples));
//compute score
double recall = coveredPosExamples.size() / (double)currentPosExamples.size();
@@ -501,7 +534,7 @@
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
+ //2. get a score for the specificity of the query, i.e. how many edges/nodes = precision oriented
int nrOfSpecificNodes = 0;
for (QueryTree<String> childNode : tree.getChildrenClosure()) {
if(!childNode.getUserObject().equals("?")){
@@ -516,33 +549,38 @@
//3.compute the total score
double score = coverageWeight * coverageScore + specifityWeight * specifityScore;
- QueryTreeScore queryTreeScore = new QueryTreeScore(score, coverageScore,
- new TreeSet<Individual>(Sets.difference(currentPosExamples, uncoveredPosExamples)), uncoveredPosExamples,
- coveredNegExamples, new TreeSet<Individual>(Sets.difference(currentNegExamples, coveredNegExamples)),
+ QueryTreeScore queryTreeScore = new QueryTreeScore(
+ score, coverageScore,
+ coveredPosExamples, uncoveredPosExamples,
+ coveredNegExamples, uncoveredNegExamples,
specifityScore, nrOfSpecificNodes);
//TODO use only the heuristic to compute the score
-// score = heuristic.getScore(evaluatedTree);
-// queryTreeScore.setScore(score);
-// queryTreeScore.setAccuracy(score);
-//
-// EvaluatedDescription evaluatedDescription = new EvaluatedDescription(d, queryTreeScore);
-//
-// evaluatedDescriptions.add(evaluatedDescription);
+ EvaluatedQueryTree<String> evaluatedTree = new EvaluatedQueryTree<String>(tree,
+ asQueryTrees(uncoveredPosExamples), asQueryTrees(coveredNegExamples), queryTreeScore);
+ score = heuristic.getScore(evaluatedTree);
+ queryTreeScore.setScore(score);
+ queryTreeScore.setAccuracy(score);
+
+
+ EvaluatedDescription evaluatedDescription = new EvaluatedDescription(d, queryTreeScore);
+
+ evaluatedTree.setDescription(evaluatedDescription);
+
+ evaluatedTrees.add(evaluatedTree);
}
-
- return evaluatedDescriptions;
+ return evaluatedTrees;
}
private EvaluatedDescription buildCombinedSolution(){
EvaluatedDescription bestCombinedSolution = null;
double bestScore = Double.NEGATIVE_INFINITY;
LiteralNodeConversionStrategy[] strategies = LiteralNodeConversionStrategy.values();
- strategies = new LiteralNodeConversionStrategy[]{LiteralNodeConversionStrategy.SOME_VALUES_FROM};
+ strategies = new LiteralNodeConversionStrategy[]{LiteralNodeConversionStrategy.DATATYPE};
for (LiteralNodeConversionStrategy strategy : strategies) {
EvaluatedDescription combinedSolution;
if(partialSolutions.size() == 1){
- combinedSolution = partialSolutions.get(0).asEvaluatedDescription(strategy);
+ combinedSolution = partialSolutions.get(0).getEvaluatedDescription();
} else {
List<Description> disjuncts = new ArrayList<Description>();
@@ -552,8 +590,7 @@
//build the union of all class expressions
Description partialDescription;
for (EvaluatedQueryTree<String> partialSolution : partialSolutions) {
- partialDescription = DLLearnerDescriptionConvertVisitor.getDLLearnerDescription(
- partialSolution.getTree().asOWLClassExpression(strategy));
+ partialDescription = partialSolution.getEvaluatedDescription().getDescription();
disjuncts.add(partialDescription);
posCovered.addAll(partialSolution.getTreeScore().getCoveredPositives());
negCovered.addAll(partialSolution.getTreeScore().getCoveredNegatives());
@@ -679,11 +716,12 @@
return individuals;
}
- private void asTree(Description d){
- QueryTree<String> tree = new QueryTreeImpl<String>("");
- for (Description child : d.getChildren()) {
-
+ private Set<QueryTree<String>> asQueryTrees(Collection<Individual> individuals){
+ Set<QueryTree<String>> trees = new HashSet<QueryTree<String>>(individuals.size());
+ for (Individual ind : individuals) {
+ trees.add(individual2Tree.get(ind));
}
+ return trees;
}
/**
@@ -802,16 +840,23 @@
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())){
+ //this is a workaround as we have currently no equals method for trees based on the literal conversion strategy
+// boolean sameTree = sameTrees(solution.getTree(), evTree.getTree());
+ boolean sameTree = OWLAPIConverter.getOWLAPIDescription(evTree.getEvaluatedDescription().getDescription()).toString()
+ .equals(OWLAPIConverter.getOWLAPIDescription(solution.getEvaluatedDescription().getDescription()).toString());
+ if(sameTree){
+ logger.warn("Not added to TODO list: Already contained in.");
return;
}
}
//check if not already contained in solutions
for (EvaluatedQueryTree<String> evTree : currentPartialSolutions) {
if(sameTrees(solution.getTree(), evTree.getTree())){
+ logger.warn("Not added to partial solutions list: Already contained in.");
return;
}
}
+ logger.info("Added to TODO list.");
todoList.add(solution);
}
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2DisjunctiveMT.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2DisjunctiveMT.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/QTL2DisjunctiveMT.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -240,7 +240,7 @@
public EvaluatedDescription getCurrentlyBestEvaluatedDescription() {
EvaluatedQueryTree<String> bestSolution = solutions.first();
Description description = DLLearnerDescriptionConvertVisitor.getDLLearnerDescription(
- bestSolution.getTree().asOWLClassExpression(LiteralNodeConversionStrategy.FACET_RESTRICTION));
+ bestSolution.getTree().asOWLClassExpression(LiteralNodeConversionStrategy.MIN_MAX));
return new EvaluatedDescription(description, bestSolution.getTreeScore());
}
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-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/datastructures/impl/QueryTreeImpl.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -118,11 +118,11 @@
/**
* Literals as an interval on the datatype, e.g. [>= 5 <=10]
*/
- FACET_RESTRICTION,
+ MIN_MAX,
/**
* Literals as datatype, e.g. xsd:integer
*/
- SOME_VALUES_FROM,
+ DATATYPE,
MIN,
@@ -207,7 +207,7 @@
if(nodeType == NodeType.RESOURCE){
isResourceNode = true;
} else if(nodeType == NodeType.LITERAL){
- isResourceNode = true;
+ isLiteralNode = true;
}
}
@@ -1405,7 +1405,7 @@
* are transformed into existential restrictions.
*/
public OWLClassExpression asOWLClassExpression(){
- return asOWLClassExpression(LiteralNodeConversionStrategy.SOME_VALUES_FROM);
+ return asOWLClassExpression(LiteralNodeConversionStrategy.DATATYPE);
}
/**
@@ -1430,7 +1430,7 @@
for(QueryTree<N> child : children){
String childLabel = (String) child.getUserObject();
String predicateString = (String) tree.getEdge(child);
- if(predicateString.equals(RDF.type.getURI())){
+ if(predicateString.equals(RDF.type.getURI()) || predicateString.equals(RDFS.subClassOf.getURI())){//A
if(child.isVarNode()){
classExpressions.addAll(buildOWLClassExpressions(df, child, literalNodeConversionStrategy));
} else {
@@ -1438,25 +1438,17 @@
classExpressions.add(df.getOWLClass(IRI.create(childLabel)));
}
}
- } else if(predicateString.equals(RDFS.subClassOf.getURI())){
- if(child.isVarNode()){
- classExpressions.addAll(buildOWLClassExpressions(df, child, literalNodeConversionStrategy));
- } else {
- if(!childLabel.equals(OWL.Thing.getURI())){//avoid trivial owl:Thing statements
- classExpressions.add(df.getOWLClass(IRI.create(childLabel)));
- }
- }
} else {
if(child.isLiteralNode()){
OWLDataProperty p = df.getOWLDataProperty(IRI.create((String) tree.getEdge(child)));
- if(childLabel.equals("?")){
+ if(childLabel.equals("?")){//p some int
Set<Literal> literals = child.getLiterals();
OWLDataRange dataRange = null;
if(literals.isEmpty()){//happens if there are heterogeneous datatypes
String datatypeURI = OWL2Datatype.RDFS_LITERAL.getURI().toString();
dataRange = df.getOWLDatatype(IRI.create(datatypeURI));
} else {
- if(literalNodeConversionStrategy == LiteralNodeConversionStrategy.SOME_VALUES_FROM){
+ if(literalNodeConversionStrategy == LiteralNodeConversionStrategy.DATATYPE){
Literal lit = literals.iterator().next();
RDFDatatype datatype = lit.getDatatype();
String datatypeURI;
@@ -1468,7 +1460,7 @@
dataRange = df.getOWLDatatype(IRI.create(datatypeURI));
} else if(literalNodeConversionStrategy == LiteralNodeConversionStrategy.DATA_ONE_OF){
dataRange = asDataOneOf(df, literals);
- } else if(literalNodeConversionStrategy == LiteralNodeConversionStrategy.FACET_RESTRICTION){
+ } else if(literalNodeConversionStrategy == LiteralNodeConversionStrategy.MIN_MAX){
dataRange = asFacet(df, literals);
} else if(literalNodeConversionStrategy == LiteralNodeConversionStrategy.MIN){
dataRange = asMinFacet(df, literals);
@@ -1477,7 +1469,7 @@
}
}
classExpressions.add(df.getOWLDataSomeValuesFrom(p, dataRange));
- } else {
+ } else {//p value 1.2
Set<Literal> literals = child.getLiterals();
Literal lit = literals.iterator().next();
OWLLiteral owlLiteral = asOWLLiteral(df, lit);
@@ -1486,7 +1478,7 @@
} else {
OWLObjectProperty p = df.getOWLObjectProperty(IRI.create((String) tree.getEdge(child)));
OWLClassExpression filler;
- if(child.isVarNode()){
+ if(child.isVarNode()){//p some C
Set<OWLClassExpression> fillerClassExpressions = buildOWLClassExpressions(df, child, literalNodeConversionStrategy);
if(fillerClassExpressions.isEmpty()){
filler = df.getOWLThing();
@@ -1496,7 +1488,7 @@
filler = df.getOWLObjectIntersectionOf(fillerClassExpressions);
}
classExpressions.add(df.getOWLObjectSomeValuesFrom(p, filler));
- } else {
+ } else {//p value {a}
classExpressions.add(df.getOWLObjectHasValue(p, df.getOWLNamedIndividual(IRI.create(childLabel))));
}
}
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/operations/lgg/EvaluatedQueryTree.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/operations/lgg/EvaluatedQueryTree.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/operations/lgg/EvaluatedQueryTree.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -5,6 +5,7 @@
import org.dllearner.algorithms.qtl.datastructures.QueryTree;
import org.dllearner.algorithms.qtl.datastructures.impl.QueryTreeImpl.LiteralNodeConversionStrategy;
import org.dllearner.core.EvaluatedDescription;
+import org.dllearner.core.owl.Description;
import org.dllearner.learningproblems.QueryTreeScore;
import org.dllearner.utilities.owl.DLLearnerDescriptionConvertVisitor;
@@ -18,6 +19,8 @@
private Collection<QueryTree<N>> falsePositives;
private QueryTreeScore score;
// private ScoreTwoValued score;
+
+ private EvaluatedDescription description;
public EvaluatedQueryTree(QueryTree<N> tree, Collection<QueryTree<N>> falseNegatives,
Collection<QueryTree<N>> falsePositives, QueryTreeScore score) {
@@ -61,7 +64,8 @@
@Override
public int compareTo(EvaluatedQueryTree<N> other) {
return ComparisonChain.start()
- .compare(this.getScore(), other.getScore())
+// .compare(this.getScore(), other.getScore())
+ .compare(other.getScore(), this.getScore())
.result();
// double diff = getScore() - other.getScore();
// if(diff == 0){
@@ -73,9 +77,26 @@
// }
}
+
+ /**
+ * @return the description
+ */
+ public EvaluatedDescription getEvaluatedDescription() {
+ return asEvaluatedDescription();
+ }
+ /**
+ * @param description the description to set
+ */
+ public void setDescription(EvaluatedDescription description) {
+ this.description = description;
+ }
+
public EvaluatedDescription asEvaluatedDescription(){
- return new EvaluatedDescription(DLLearnerDescriptionConvertVisitor.getDLLearnerDescription(
- getTree().asOWLClassExpression(LiteralNodeConversionStrategy.FACET_RESTRICTION)), score);
+ if(description == null){
+ description = new EvaluatedDescription(DLLearnerDescriptionConvertVisitor.getDLLearnerDescription(
+ getTree().asOWLClassExpression(LiteralNodeConversionStrategy.MIN_MAX)), score);
+ }
+ return description;
}
public EvaluatedDescription asEvaluatedDescription(LiteralNodeConversionStrategy strategy){
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/util/QueryTreeConverter.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/util/QueryTreeConverter.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/qtl/util/QueryTreeConverter.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -4,10 +4,17 @@
package org.dllearner.algorithms.qtl.util;
import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
import java.util.Stack;
+import javax.xml.bind.DatatypeConverter;
+
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.datastructures.impl.QueryTreeImpl.NodeType;
import org.semanticweb.owlapi.apibinding.OWLManager;
import org.semanticweb.owlapi.io.ToStringRenderer;
@@ -24,11 +31,15 @@
import org.semanticweb.owlapi.model.OWLDataMaxCardinality;
import org.semanticweb.owlapi.model.OWLDataMinCardinality;
import org.semanticweb.owlapi.model.OWLDataOneOf;
+import org.semanticweb.owlapi.model.OWLDataProperty;
+import org.semanticweb.owlapi.model.OWLDataRange;
import org.semanticweb.owlapi.model.OWLDataRangeVisitor;
import org.semanticweb.owlapi.model.OWLDataSomeValuesFrom;
import org.semanticweb.owlapi.model.OWLDataUnionOf;
import org.semanticweb.owlapi.model.OWLDatatype;
import org.semanticweb.owlapi.model.OWLDatatypeRestriction;
+import org.semanticweb.owlapi.model.OWLFacetRestriction;
+import org.semanticweb.owlapi.model.OWLLiteral;
import org.semanticweb.owlapi.model.OWLObjectAllValuesFrom;
import org.semanticweb.owlapi.model.OWLObjectComplementOf;
import org.semanticweb.owlapi.model.OWLObjectExactCardinality;
@@ -38,20 +49,24 @@
import org.semanticweb.owlapi.model.OWLObjectMaxCardinality;
import org.semanticweb.owlapi.model.OWLObjectMinCardinality;
import org.semanticweb.owlapi.model.OWLObjectOneOf;
+import org.semanticweb.owlapi.model.OWLObjectProperty;
import org.semanticweb.owlapi.model.OWLObjectSomeValuesFrom;
import org.semanticweb.owlapi.model.OWLObjectUnionOf;
-import org.semanticweb.owlapi.model.OWLOntology;
-import org.semanticweb.owlapi.model.OWLOntologyChange;
import org.semanticweb.owlapi.model.OWLOntologyManager;
import org.semanticweb.owlapi.model.PrefixManager;
-import org.semanticweb.owlapi.reasoner.OWLReasoner;
-import org.semanticweb.owlapi.reasoner.OWLReasonerFactory;
import org.semanticweb.owlapi.util.DefaultPrefixManager;
+import org.semanticweb.owlapi.vocab.OWL2Datatype;
+import org.semanticweb.owlapi.vocab.OWLFacet;
+import uk.ac.manchester.cs.owl.owlapi.OWLDataFactoryImpl;
import uk.ac.manchester.cs.owlapi.dlsyntax.DLSyntaxObjectRenderer;
-import com.clarkparsia.pellet.owlapiv3.PelletReasonerFactory;
+import com.hp.hpl.jena.datatypes.RDFDatatype;
+import com.hp.hpl.jena.datatypes.xsd.XSDDatatype;
+import com.hp.hpl.jena.rdf.model.Literal;
+import com.hp.hpl.jena.vocabulary.OWL;
import com.hp.hpl.jena.vocabulary.RDF;
+import com.hp.hpl.jena.vocabulary.RDFS;
/**
* Converts query trees into OWL class expressions and vice versa.
@@ -60,6 +75,8 @@
*/
public class QueryTreeConverter implements OWLClassExpressionVisitor, OWLDataRangeVisitor{
+ OWLDataFactory df = new OWLDataFactoryImpl();
+
Stack<QueryTree<String>> stack = new Stack<QueryTree<String>>();
int id = 0;
@@ -67,12 +84,213 @@
* Returns a OWL class expression of the union of the given query trees.
* @param queryTrees
*/
- public void asOWLClassExpression(Collection<QueryTree<String>> queryTrees){
-
- //check for common paths
-
+ public OWLClassExpression asOWLClassExpression(QueryTree<String> tree){
+ Set<OWLClassExpression> classExpressions = asOWLClassExpressions(tree);
+ OWLClassExpression expression;
+ if(classExpressions.isEmpty()){
+ expression = df.getOWLThing();
+ } else if(classExpressions.size() == 1){
+ expression = classExpressions.iterator().next();
+ } else {
+ expression = df.getOWLObjectIntersectionOf(classExpressions);
+ }
+ return expression;
}
+ /**
+ * Returns a OWL class expression representation of the given query tree.
+ * @param queryTrees
+ */
+ public Set<OWLClassExpression> asOWLClassExpressions(QueryTree<String> tree){
+ Set<OWLClassExpression> classExpressions = new HashSet<OWLClassExpression>();
+
+ List<QueryTree<String>> children = tree.getChildren();
+ for(QueryTree<String> child : children){
+ String childLabel = (String) child.getUserObject();
+ String predicateString = (String) tree.getEdge(child);
+ if(predicateString.equals(RDF.type.getURI()) || predicateString.equals(RDFS.subClassOf.getURI())){//A
+ if(child.isVarNode()){
+ classExpressions.addAll(asOWLClassExpressions(child));
+ } else {
+ if(!childLabel.equals(OWL.Thing.getURI())){//avoid trivial owl:Thing statements
+ classExpressions.add(df.getOWLClass(IRI.create(childLabel)));
+ }
+ }
+ } else {
+ if(child.isLiteralNode()){
+ OWLDataProperty p = df.getOWLDataProperty(IRI.create((String) tree.getEdge(child)));
+ if(childLabel.equals("?")){//p some int
+ Set<Literal> literals = child.getLiterals();
+ OWLDataRange dataRange = null;
+ if(literals.isEmpty()){//happens if there are heterogeneous datatypes
+ String datatypeURI = OWL2Datatype.RDFS_LITERAL.getURI().toString();
+ dataRange = df.getOWLDatatype(IRI.create(datatypeURI));
+ } else {
+ for (LiteralNodeConversionStrategy strategy : LiteralNodeConversionStrategy.values()) {
+ if(strategy == LiteralNodeConversionStrategy.DATATYPE){
+ Literal lit = literals.iterator().next();
+ RDFDatatype datatype = lit.getDatatype();
+ String datatypeURI;
+ if(datatype == null){
+ datatypeURI = OWL2Datatype.RDF_PLAIN_LITERAL.getURI().toString();
+ } else {
+ datatypeURI = datatype.getURI();
+ }
+ dataRange = df.getOWLDatatype(IRI.create(datatypeURI));
+ } else if(strategy == LiteralNodeConversionStrategy.DATA_ONE_OF){
+ dataRange = asDataOneOf(df, literals);
+ } else if(strategy == LiteralNodeConversionStrategy.MIN_MAX){
+ dataRange = asFacet(df, literals);
+ } else if(strategy == LiteralNodeConversionStrategy.MIN){
+ dataRange = asMinFacet(df, literals);
+ } else if(strategy == LiteralNodeConversionStrategy.MAX){
+ dataRange = asMaxFacet(df, literals);
+ }
+ }
+ }
+ classExpressions.add(df.getOWLDataSomeValuesFrom(p, dataRange));
+ } else {//p value 1.2
+ Set<Literal> literals = child.getLiterals();
+ Literal lit = literals.iterator().next();
+ OWLLiteral owlLiteral = asOWLLiteral(df, lit);
+ classExpressions.add(df.getOWLDataHasValue(p, owlLiteral));
+ }
+ } else {
+ OWLObjectProperty p = df.getOWLObjectProperty(IRI.create((String) tree.getEdge(child)));
+ OWLClassExpression filler;
+ if(child.isVarNode()){//p some C
+ Set<OWLClassExpression> fillerClassExpressions = asOWLClassExpressions(child);
+ if(fillerClassExpressions.isEmpty()){
+ filler = df.getOWLThing();
+ } else if(fillerClassExpressions.size() == 1){
+ filler = fillerClassExpressions.iterator().next();
+ } else {
+ filler = df.getOWLObjectIntersectionOf(fillerClassExpressions);
+ }
+ classExpressions.add(df.getOWLObjectSomeValuesFrom(p, filler));
+ } else {//p value {a}
+ classExpressions.add(df.getOWLObjectHasValue(p, df.getOWLNamedIndividual(IRI.create(childLabel))));
+ }
+ }
+ }
+ }
+ return classExpressions;
+ }
+
+ private OWLDataRange asFacet(OWLDataFactory df, Set<Literal> literals){
+ //return Boolean datatype because it doesn't make sense to return a facet of Boolean values
+ if(getOWLDatatype(df, literals).equals(df.getBooleanOWLDatatype())){
+ return df.getBooleanOWLDatatype();
+ }
+ Literal min = getMin(literals);
+ Literal max = getMax(literals);
+
+ OWLFacetRestriction minRestriction = df.getOWLFacetRestriction(OWLFacet.MIN_INCLUSIVE, asOWLLiteral(df, min));
+ OWLFacetRestriction maxRestriction = df.getOWLFacetRestriction(OWLFacet.MAX_INCLUSIVE, asOWLLiteral(df, max));
+
+ return df.getOWLDatatypeRestriction(getOWLDatatype(df, literals), minRestriction, maxRestriction);
+ }
+
+ private OWLDataRange asMinFacet(OWLDataFactory df, Set<Literal> literals){
+ //return Boolean datatype because it doesn't make sense to return a facet of Boolean values
+ if(getOWLDatatype(df, literals).equals(df.getBooleanOWLDatatype())){
+ return df.getBooleanOWLDatatype();
+ }
+ Literal min = getMin(literals);
+
+ OWLFacetRestriction minRestriction = df.getOWLFacetRestriction(OWLFacet.MIN_INCLUSIVE, asOWLLiteral(df, min));
+
+ return df.getOWLDatatypeRestriction(getOWLDatatype(df, literals), minRestriction);
+ }
+
+ private OWLDataRange asMaxFacet(OWLDataFactory df, Set<Literal> literals){
+ //return Boolean datatype because it doesn't make sense to return a facet of Boolean values
+ if(getOWLDatatype(df, literals).equals(df.getBooleanOWLDatatype())){
+ return df.getBooleanOWLDatatype();
+ }
+ Literal max = getMax(literals);
+
+ OWLFacetRestriction maxRestriction = df.getOWLFacetRestriction(OWLFacet.MAX_INCLUSIVE, asOWLLiteral(df, max));
+
+ return df.getOWLDatatypeRestriction(getOWLDatatype(df, literals), maxRestriction);
+ }
+
+ private OWLDataRange asDataOneOf(OWLDataFactory df, Set<Literal> literals){
+ //return Boolean datatype because it doesn't make sense to return a enumeration of Boolean values
+ if(getOWLDatatype(df, literals).equals(df.getBooleanOWLDatatype())){
+ return df.getBooleanOWLDatatype();
+ }
+ return df.getOWLDataOneOf(asOWLLiterals(df, literals));
+ }
+
+ private Set<OWLLiteral> asOWLLiterals(OWLDataFactory df, Set<Literal> literals){
+ Set<OWLLiteral> owlLiterals = new HashSet<OWLLiteral>(literals.size());
+ for (Literal literal : literals) {
+ owlLiterals.add(asOWLLiteral(df, literal));
+ }
+ return owlLiterals;
+ }
+
+ private OWLLiteral asOWLLiteral(OWLDataFactory df, Literal literal){
+ OWLLiteral owlLiteral;
+ if(literal.getDatatypeURI() == null){
+ owlLiteral = df.getOWLLiteral(literal.getLexicalForm(), literal.getLanguage());
+ } else {
+ owlLiteral = df.getOWLLiteral(literal.getLexicalForm(), df.getOWLDatatype(IRI.create(literal.getDatatypeURI())));
+ }
+ return owlLiteral;
+ }
+
+ private Literal getMin(Set<Literal> literals){
+ Iterator<Literal> iter = literals.iterator();
+ Literal min = iter.next();
+ Literal l;
+ while(iter.hasNext()){
+ l = iter.next();
+ if(l.getDatatype() == XSDDatatype.XSDinteger || l.getDatatype() == XSDDatatype.XSDint){
+ min = (l.getInt() < min.getInt()) ? l : min;
+ } else if(l.getDatatype() == XSDDatatype.XSDdouble || l.getDatatype() == XSDDatatype.XSDdecimal){
+ min = (l.getDouble() < min.getDouble()) ? l : min;
+ } else if(l.getDatatype() == XSDDatatype.XSDfloat){
+ min = (l.getFloat() < min.getFloat()) ? l : min;
+ } else if(l.getDatatype() == XSDDatatype.XSDdate){
+ min = (DatatypeConverter.parseDate(l.getLexicalForm()).compareTo(DatatypeConverter.parseDate(min.getLexicalForm())) == -1) ? l : min;
+ }
+ }
+ return min;
+ }
+
+ private Literal getMax(Set<Literal> literals){
+ Iterator<Literal> iter = literals.iterator();
+ Literal max = iter.next();
+ Literal l;
+ while(iter.hasNext()){
+ l = iter.next();
+ if(l.getDatatype() == XSDDatatype.XSDinteger || l.getDatatype() == XSDDatatype.XSDint){
+ max = (l.getInt() > max.getInt()) ? l : max;
+ } else if(l.getDatatype() == XSDDatatype.XSDdouble || l.getDatatype() == XSDDatatype.XSDdecimal){
+ max = (l.getDouble() > max.getDouble()) ? l : max;
+ } else if(l.getDatatype() == XSDDatatype.XSDfloat){
+ max = (l.getFloat() > max.getFloat()) ? l : max;
+ } else if(l.getDatatype() == XSDDatatype.XSDdate){
+ max = (DatatypeConverter.parseDate(l.getLexicalForm()).compareTo(DatatypeConverter.parseDate(max.getLexicalForm())) == 1) ? l : max;
+ }
+ }
+ return max;
+ }
+
+ private OWLDatatype getOWLDatatype(OWLDataFactory df, Set<Literal> literals){
+ return df.getOWLDatatype(IRI.create(literals.iterator().next().getDatatypeURI()));
+ }
+
+
+ /**
+ * Converts a OWL class expression into a query tree, if possible. Note that this is not possible
+ * for all OWL constructs, e.g. universal restrictions are not allowed. An exceptions is thrown if the conversion
+ * fails.
+ * @param expression
+ * @return
+ */
public QueryTree<String> asQueryTree(OWLClassExpression expression){
// stack.push(new QueryTreeImpl<String>("?"));
reset();
Modified: trunk/components-core/src/main/java/org/dllearner/core/AbstractCELA.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/core/AbstractCELA.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/core/AbstractCELA.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -52,7 +52,7 @@
* @author Jens Lehmann
*
*/
-public abstract class AbstractCELA extends AbstractComponent implements ClassExpressionLearningAlgorithm, StoppableLearningAlgorithm, Cloneable {
+public abstract class AbstractCELA extends AbstractComponent implements ClassExpressionLearningAlgorithm, StoppableLearningAlgorithm {
protected EvaluatedDescriptionSet bestEvaluatedDescriptions = new EvaluatedDescriptionSet(AbstractCELA.MAX_NR_OF_RESULTS);
protected DecimalFormat dfPercent = new DecimalFormat("0.00%");
Modified: trunk/components-core/src/main/java/org/dllearner/core/owl/Constant.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/core/owl/Constant.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/core/owl/Constant.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -19,17 +19,16 @@
package org.dllearner.core.owl;
+import java.io.Serializable;
+
/**
* A constant value.
*
* @author Jens Lehmann
*
*/
-public abstract class Constant implements KBElement, Comparable<Constant> {
+public abstract class Constant implements KBElement, Comparable<Constant>, Serializable {
- /**
- *
- */
private static final long serialVersionUID = 2331790456049452753L;
String literal;
Modified: trunk/components-core/src/main/java/org/dllearner/core/owl/DatatypeProperty.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/core/owl/DatatypeProperty.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/core/owl/DatatypeProperty.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -31,9 +31,6 @@
*/
public class DatatypeProperty implements Comparable<DatatypeProperty>, Property, NamedKBElement, Serializable {
- /**
- *
- */
private static final long serialVersionUID = 8452865438915671952L;
protected String name;
Modified: trunk/components-core/src/main/java/org/dllearner/core/owl/DoubleMaxValue.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/core/owl/DoubleMaxValue.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/core/owl/DoubleMaxValue.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -58,11 +58,11 @@
* @see org.dllearner.core.owl.KBElement#toString(java.lang.String, java.util.Map)
*/
public String toString(String baseURI, Map<String, String> prefixes) {
- return " double[<= " + value + "]";
+ return "double[<= " + value + "]";
}
public String toKBSyntaxString(String baseURI, Map<String, String> prefixes) {
- return " double[<= " + value + "]";
+ return "double[<= " + value + "]";
}
public void accept(KBElementVisitor visitor) {
@@ -74,7 +74,7 @@
*/
@Override
public String toManchesterSyntaxString(String baseURI, Map<String, String> prefixes) {
- return " double[<= " + value + "]";
+ return "double[<= " + value + "]";
}
/* (non-Javadoc)
Modified: trunk/components-core/src/main/java/org/dllearner/core/owl/DoubleMinMaxRange.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/core/owl/DoubleMinMaxRange.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/core/owl/DoubleMinMaxRange.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -65,11 +65,11 @@
* @see org.dllearner.core.owl.KBElement#toString(java.lang.String, java.util.Map)
*/
public String toString(String baseURI, Map<String, String> prefixes) {
- return " double[>= " + minValue + " <= " + maxValue + "]";
+ return "double[>= " + minValue + ", <= " + maxValue + "]";
}
public String toKBSyntaxString(String baseURI, Map<String, String> prefixes) {
- return " double[>= " + minValue + " <= " + maxValue + "]";
+ return "double[>= " + minValue + ", <= " + maxValue + "]";
}
public void accept(KBElementVisitor visitor) {
@@ -81,7 +81,7 @@
*/
@Override
public String toManchesterSyntaxString(String baseURI, Map<String, String> prefixes) {
- return " double[>= " + minValue + " <= " + maxValue + "]";
+ return "double[>= " + minValue + ", <= " + maxValue + "]";
}
/* (non-Javadoc)
Modified: trunk/components-core/src/main/java/org/dllearner/core/owl/DoubleMinValue.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/core/owl/DoubleMinValue.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/core/owl/DoubleMinValue.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -58,11 +58,11 @@
* @see org.dllearner.core.owl.KBElement#toString(java.lang.String, java.util.Map)
*/
public String toString(String baseURI, Map<String, String> prefixes) {
- return " double[>= " + value + "]";
+ return "double[>= " + value + "]";
}
public String toKBSyntaxString(String baseURI, Map<String, String> prefixes) {
- return " double[>= " + value + "]";
+ return "double[>= " + value + "]";
}
public void accept(KBElementVisitor visitor) {
@@ -74,7 +74,7 @@
*/
@Override
public String toManchesterSyntaxString(String baseURI, Map<String, String> prefixes) {
- return " double[>= " + value + "]";
+ return "double[>= " + value + "]";
}
/* (non-Javadoc)
Modified: trunk/components-core/src/main/java/org/dllearner/core/owl/ObjectProperty.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/core/owl/ObjectProperty.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/core/owl/ObjectProperty.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -19,6 +19,7 @@
package org.dllearner.core.owl;
+import java.io.Serializable;
import java.net.URI;
import java.util.Map;
@@ -31,7 +32,7 @@
* @author Jens Lehmann
*
*/
-public class ObjectProperty extends ObjectPropertyExpression implements Property, Comparable<ObjectProperty>{
+public class ObjectProperty extends ObjectPropertyExpression implements Property, Comparable<ObjectProperty>, Serializable{
private static final long serialVersionUID = -3343070247923446690L;
Modified: trunk/components-core/src/main/java/org/dllearner/core/owl/TypedConstant.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/core/owl/TypedConstant.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/core/owl/TypedConstant.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -29,9 +29,6 @@
*/
public class TypedConstant extends Constant {
- /**
- *
- */
private static final long serialVersionUID = -9135242138291085300L;
private Datatype datatype;
Modified: trunk/components-core/src/main/java/org/dllearner/reasoning/ExistentialRestrictionMaterialization.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/reasoning/ExistentialRestrictionMaterialization.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/reasoning/ExistentialRestrictionMaterialization.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -6,6 +6,7 @@
import java.io.ByteArrayInputStream;
import java.util.HashMap;
import java.util.HashSet;
+import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
@@ -81,27 +82,55 @@
private Map<OWLClass, Set<OWLClassExpression>> map = new HashMap<>();
Stack<Set<OWLClassExpression>> stack = new Stack<Set<OWLClassExpression>>();
OWLDataFactory df;
+ boolean onlyIfExistentialOnPath = true;
+
+ int indent = 0;
public SuperClassFinder() {
df = ontology.getOWLOntologyManager().getOWLDataFactory();
}
public Set<OWLClassExpression> getSuperClasses(OWLClass cls){
+// System.out.println("#################");
map.clear();
computeSuperClasses(cls);
Set<OWLClassExpression> superClasses = map.get(cls);
superClasses.remove(cls);
+
+ //filter out non existential superclasses
+ if(onlyIfExistentialOnPath){
+ for (Iterator<OWLClassExpression> iterator = superClasses.iterator(); iterator.hasNext();) {
+ OWLClassExpression sup = iterator.next();
+ if (!(sup instanceof OWLObjectSomeValuesFrom || sup instanceof OWLDataAllValuesFrom)) {
+ iterator.remove();
+ }
+ }
+ }
return superClasses;
}
private void computeSuperClasses(OWLClass cls){
+ String s = "";
+ for(int i = 0; i < indent; i++){
+ s += " ";
+ }
+// System.out.println(s + cls);
+ indent++;
Set<OWLClassExpression> superClasses = new HashSet<OWLClassExpression>();
superClasses.add(cls);
+
+ //get the directly asserted super classes
Set<OWLClassExpression> superClassExpressions = cls.getSuperClasses(ontology);
+
+ //omit trivial super class
+ superClassExpressions.remove(cls);
+
+ //go subsumption hierarchy up for each directly asserted super class
for (OWLClassExpression sup : superClassExpressions) {
sup.accept(this);
superClasses.addAll(stack.pop());
}
+
stack.push(superClasses);
map.put(cls, superClasses);
}
Modified: trunk/components-core/src/main/java/org/dllearner/reasoning/FastInstanceChecker.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/reasoning/FastInstanceChecker.java 2014-07-02 06:31:52 UTC (rev 4279)
+++ trunk/components-core/src/main/java/org/dllearner/reasoning/FastInstanceChecker.java 2014-07-29 13:53:19 UTC (rev 4280)
@@ -59,6 +59,7 @@
import ...
[truncated message content] |