Menu
▾
▴
[DL-Learner SVN] SF.net SVN: dl-learner:[4142] trunk/components-core
|
From: <lor...@us...> - 2013-11-11 13:38:08
|
Revision: 4142
http://sourceforge.net/p/dl-learner/code/4142
Author: lorenz_b
Date: 2013-11-11 13:38:04 +0000 (Mon, 11 Nov 2013)
Log Message:
-----------
isle.
Modified Paths:
--------------
trunk/components-core/pom.xml
trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/PatternBasedAxiomLearningAlgorithm.java
trunk/components-core/src/main/java/org/dllearner/algorithms/properties/ObjectPropertyDomainAxiomLearner2.java
trunk/components-core/src/main/java/org/dllearner/core/AbstractAxiomLearningAlgorithm.java
trunk/components-core/src/main/java/org/dllearner/core/owl/Description.java
trunk/components-core/src/main/java/org/dllearner/core/owl/ObjectPropertyDomainAxiom.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/reasoning/fuzzydll/FuzzyDLReasonerManager.java
trunk/components-core/src/main/java/org/dllearner/utilities/datastructures/PrefixTrie.java
trunk/components-core/src/main/java/org/dllearner/utilities/owl/OWLClassExpressionToSPARQLConverter.java
trunk/components-core/src/test/java/org/dllearner/algorithms/isle/CrossValidation.java
trunk/components-core/src/test/java/org/dllearner/algorithms/isle/Experiment.java
trunk/components-core/src/test/java/org/dllearner/algorithms/isle/SemanticBibleExperiment.java
trunk/components-core/src/test/java/org/dllearner/algorithms/qtl/LGGTest.java
Modified: trunk/components-core/pom.xml
===================================================================
--- trunk/components-core/pom.xml 2013-11-08 09:29:40 UTC (rev 4141)
+++ trunk/components-core/pom.xml 2013-11-11 13:38:04 UTC (rev 4142)
@@ -172,7 +172,7 @@
</dependency>
<dependency>
- <groupId>fuzzydll</groupId>
+ <groupId>org.fuzzy</groupId>
<artifactId>fuzzydl</artifactId>
<version>1.0</version>
</dependency>
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/PatternBasedAxiomLearningAlgorithm.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/PatternBasedAxiomLearningAlgorithm.java 2013-11-08 09:29:40 UTC (rev 4141)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/pattern/PatternBasedAxiomLearningAlgorithm.java 2013-11-11 13:38:04 UTC (rev 4142)
@@ -47,6 +47,7 @@
import com.hp.hpl.jena.query.QuerySolution;
import com.hp.hpl.jena.query.ResultSet;
import com.hp.hpl.jena.query.ResultSetFormatter;
+import com.hp.hpl.jena.rdf.arp.ARPOptions;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Resource;
@@ -255,6 +256,8 @@
+ " }"
+ " FILTER ( ?cnt1 = ?cnt2 ) }";
+ query = "SELECT ?x WHERE {?x a <http://ex.org/A>. FILTER NOT EXISTS{?x <http://ex.org/p> ?s1. FILTER NOT EXISTS{?s1 a <http://ex.org/B>.}}} ";
+
rs = QueryExecutionFactory.create(query, model).execSelect();
System.out.println(ResultSetFormatter.asText(rs));
Modified: trunk/components-core/src/main/java/org/dllearner/algorithms/properties/ObjectPropertyDomainAxiomLearner2.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/algorithms/properties/ObjectPropertyDomainAxiomLearner2.java 2013-11-08 09:29:40 UTC (rev 4141)
+++ trunk/components-core/src/main/java/org/dllearner/algorithms/properties/ObjectPropertyDomainAxiomLearner2.java 2013-11-11 13:38:04 UTC (rev 4142)
@@ -20,6 +20,7 @@
package org.dllearner.algorithms.properties;
import java.util.ArrayList;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
@@ -33,19 +34,28 @@
import org.dllearner.core.EvaluatedAxiom;
import org.dllearner.core.config.ConfigOption;
import org.dllearner.core.config.ObjectPropertyEditor;
+import org.dllearner.core.owl.Axiom;
import org.dllearner.core.owl.Description;
import org.dllearner.core.owl.Individual;
+import org.dllearner.core.owl.Intersection;
import org.dllearner.core.owl.KBElement;
import org.dllearner.core.owl.NamedClass;
import org.dllearner.core.owl.ObjectProperty;
import org.dllearner.core.owl.ObjectPropertyDomainAxiom;
+import org.dllearner.core.owl.ObjectSomeRestriction;
+import org.dllearner.core.owl.SubClassAxiom;
+import org.dllearner.core.owl.Thing;
import org.dllearner.kb.SparqlEndpointKS;
import org.dllearner.kb.sparql.SparqlEndpoint;
+import org.dllearner.learningproblems.AxiomScore;
+import org.dllearner.learningproblems.Heuristics;
import org.dllearner.reasoning.SPARQLReasoner;
+import org.dllearner.utilities.owl.OWLClassExpressionToSPARQLConverter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.hp.hpl.jena.query.ParameterizedSparqlString;
+import com.hp.hpl.jena.query.Query;
import com.hp.hpl.jena.query.QuerySolution;
import com.hp.hpl.jena.query.ResultSet;
import com.hp.hpl.jena.rdf.model.Model;
@@ -113,6 +123,113 @@
logger.info("...finished in {}ms.", (System.currentTimeMillis()-startTime));
}
+ private void buildSampleFragment(){
+ workingModel = ModelFactory.createDefaultModel();
+ int limit = 10000;
+ int offset = 0;
+ String filter = "";
+ for (String ns : allowedNamespaces) {
+ filter += "FILTER(STRSTARTS(STR(?type), '" + ns + "'))";
+ }
+ ParameterizedSparqlString queryTemplate = new ParameterizedSparqlString("CONSTRUCT {?s a ?type.} WHERE {?s ?p ?o. ?s a ?type. " + filter + "}");
+ queryTemplate.setIri("p", propertyToDescribe.getName());
+ Query query = queryTemplate.asQuery();
+ query.setLimit(limit);
+ Model tmp = executeConstructQuery(query.toString());
+ workingModel.add(tmp);
+ while(!tmp.isEmpty() && !terminationCriteriaSatisfied()){
+ //increase offset by limit
+ offset += limit;
+ query.setOffset(offset);
+ //run query
+ tmp = executeConstructQuery(query.toString());
+ workingModel.add(tmp);
+ }
+ }
+
+ private void run(){
+ //extract sample fragment from KB
+ buildSampleFragment();
+
+ //generate a set of axiom candidates
+ computeAxiomCandidates();
+
+ //compute evidence score on the whole KB
+ List<Axiom> axioms = getCurrentlyBestAxioms();
+ currentlyBestAxioms = new ArrayList<EvaluatedAxiom>();
+ //get total number of instances of A
+ int cntA = reasoner.getPopularity(propertyToDescribe);
+ OWLClassExpressionToSPARQLConverter converter = new OWLClassExpressionToSPARQLConverter();
+ for (Axiom axiom : axioms) {
+ //get total number of instances of B
+ NamedClass domain = ((ObjectPropertyDomainAxiom)axiom).getDomain().asNamedClass();
+ int cntB = reasoner.getPopularity(domain);
+
+ //get number of instances of (A AND B)
+ Query query = converter.asCountQuery(new Intersection(domain, new ObjectSomeRestriction(propertyToDescribe, new Thing())));
+// System.out.println(query);
+ int cntAB = executeSelectQuery(query.toString()).next().getLiteral("cnt").getInt();
+
+ //precision (A AND B)/B
+ double precision = Heuristics.getConfidenceInterval95WaldAverage(cntB, cntAB);
+
+ //recall (A AND B)/A
+ double recall = Heuristics.getConfidenceInterval95WaldAverage(cntA, cntAB);
+
+ //beta
+ double beta = 3.0;
+
+ //F score
+ double fscore = Heuristics.getFScore(recall, precision, beta);
+ System.out.println(axiom + ":" + fscore + "(P=" + precision + "|R=" + recall + ")");
+ currentlyBestAxioms.add(new EvaluatedAxiom(axiom, new AxiomScore(fscore)));
+// System.out.println(new EvaluatedAxiom(axiom, new AxiomScore(fscore)));
+ }
+ }
+
+ private void computeAxiomCandidates() {
+ currentlyBestAxioms = new ArrayList<EvaluatedAxiom>();
+ // get number of distinct subjects
+ String query = "SELECT (COUNT(DISTINCT ?s) AS ?all) WHERE {?s a ?type.}";
+ ResultSet rs = executeSelectQuery(query, workingModel);
+ QuerySolution qs;
+ int all = 1;
+ while (rs.hasNext()) {
+ qs = rs.next();
+ all = qs.getLiteral("all").getInt();
+ }
+
+ // get class and number of instances
+ query = "SELECT ?type (COUNT(DISTINCT ?s) AS ?cnt) WHERE {?s a ?type.} GROUP BY ?type ORDER BY DESC(?cnt)";
+ rs = executeSelectQuery(query, workingModel);
+
+ if (all > 0) {
+ currentlyBestAxioms.clear();
+ while (rs.hasNext()) {
+ qs = rs.next();
+ Resource type = qs.get("type").asResource();
+ // omit owl:Thing as trivial domain
+ if (type.equals(OWL.Thing)) {
+ continue;
+ }
+ currentlyBestAxioms.add(new EvaluatedAxiom(new ObjectPropertyDomainAxiom(propertyToDescribe,
+ new NamedClass(type.getURI())), computeScore(all, qs.get("cnt").asLiteral().getInt())));
+ }
+ }
+ }
+
+ private void computeLocalScore(){
+
+ }
+
+ private void computeScore(Set<ObjectPropertyDomainAxiom> axioms){
+ OWLClassExpressionToSPARQLConverter converter = new OWLClassExpressionToSPARQLConverter();
+ for (ObjectPropertyDomainAxiom axiom : axioms) {
+ SubClassAxiom sub = axiom.asSubClassOfAxiom();
+ String subClassQuery = converter.convert("?s", sub.getSubConcept());
+ }
+ }
+
private void runSPARQL1_0_Mode() {
workingModel = ModelFactory.createDefaultModel();
int limit = 1000;
@@ -193,29 +310,34 @@
org.apache.log4j.Logger.getRootLogger().setLevel(Level.INFO);
org.apache.log4j.Logger.getLogger(DataPropertyDomainAxiomLearner.class).setLevel(Level.INFO);
- SparqlEndpointKS ks = new SparqlEndpointKS(SparqlEndpoint.getEndpointDBpedia());
+ SparqlEndpointKS ks = new SparqlEndpointKS(SparqlEndpoint.getEndpointDBpedia(), "cache");
- SPARQLReasoner reasoner = new SPARQLReasoner(ks);
+ SPARQLReasoner reasoner = new SPARQLReasoner(ks, "cache");
reasoner.prepareSubsumptionHierarchy();
ObjectPropertyDomainAxiomLearner2 l = new ObjectPropertyDomainAxiomLearner2(ks);
l.setReasoner(reasoner);
- l.setPropertyToDescribe(new ObjectProperty("http://dbpedia.org/ontology/league"));
- l.setMaxFetchedRows(20000);
- l.setMaxExecutionTimeInSeconds(20);
- l.addFilterNamespace("http://dbpedia.org/ontology/");
-// l.setReturnOnlyNewAxioms(true);
- l.init();
- l.start();
+ for (ObjectProperty p : reasoner.getOWLObjectProperties("http://dbpedia.org/ontology/")) {
+ System.out.println(p);
+ l.setPropertyToDescribe(p);
+ l.setMaxExecutionTimeInSeconds(10);
+ l.addFilterNamespace("http://dbpedia.org/ontology/");
+// l.setReturnOnlyNewAxioms(true);
+ l.init();
+// l.start();
+ l.run();
+ List<EvaluatedAxiom> axioms = l.getCurrentlyBestEvaluatedAxioms(10, 0.5);
+// System.out.println(axioms);
+ System.out.println(l.getBestEvaluatedAxiom());
+ }
- List<EvaluatedAxiom> axioms = l.getCurrentlyBestEvaluatedAxioms(10, 0.3);
- System.out.println(axioms);
- for(EvaluatedAxiom axiom : axioms){
- printSubset(l.getPositiveExamples(axiom), 10);
- printSubset(l.getNegativeExamples(axiom), 10);
- l.explainScore(axiom);
- }
+
+// for(EvaluatedAxiom axiom : axioms){
+// printSubset(l.getPositiveExamples(axiom), 10);
+// printSubset(l.getNegativeExamples(axiom), 10);
+// l.explainScore(axiom);
+// }
}
}
Modified: trunk/components-core/src/main/java/org/dllearner/core/AbstractAxiomLearningAlgorithm.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/core/AbstractAxiomLearningAlgorithm.java 2013-11-08 09:29:40 UTC (rev 4141)
+++ trunk/components-core/src/main/java/org/dllearner/core/AbstractAxiomLearningAlgorithm.java 2013-11-11 13:38:04 UTC (rev 4142)
@@ -118,7 +118,7 @@
protected boolean fullDataLoaded = false;
- private List<String> filterNamespaces = new ArrayList<String>();
+ protected List<String> allowedNamespaces = new ArrayList<String>();
protected ParameterizedSparqlString iterativeQueryTemplate;
@@ -274,6 +274,13 @@
return returnList;
}
+ public EvaluatedAxiom getBestEvaluatedAxiom(){
+ if(!currentlyBestAxioms.isEmpty()){
+ return new TreeSet<EvaluatedAxiom>(currentlyBestAxioms).last();
+ }
+ return null;
+ }
+
protected Set<NamedClass> getAllClasses() {
if(ks.isRemote()){
return new SPARQLTasks(((SparqlEndpointKS) ks).getEndpoint()).getAllClasses();
@@ -457,7 +464,7 @@
private Query buildQuery(){
Query query = iterativeQueryTemplate.asQuery();
- for(String ns : filterNamespaces){
+ for(String ns : allowedNamespaces){
((ElementGroup)query.getQueryPattern()).addElementFilter(
new ElementFilter(
new E_Regex(
@@ -470,7 +477,7 @@
}
public void addFilterNamespace(String namespace){
- filterNamespaces.add(namespace);
+ allowedNamespaces.add(namespace);
}
public Set<KBElement> getPositiveExamples(EvaluatedAxiom axiom){
Modified: trunk/components-core/src/main/java/org/dllearner/core/owl/Description.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/core/owl/Description.java 2013-11-08 09:29:40 UTC (rev 4141)
+++ trunk/components-core/src/main/java/org/dllearner/core/owl/Description.java 2013-11-11 13:38:04 UTC (rev 4142)
@@ -239,8 +239,9 @@
} else if(propertyExpression instanceof DatatypeProperty){
entities.add((DatatypeProperty)propertyExpression);
}
- entities.addAll(getChild(0).getSignature());
-
+ if(!(this instanceof ObjectValueRestriction || this instanceof DatatypeValueRestriction) ){
+ entities.addAll(getChild(0).getSignature());
+ }
} else {
for (Description child : children) {
entities.addAll(child.getSignature());
Modified: trunk/components-core/src/main/java/org/dllearner/core/owl/ObjectPropertyDomainAxiom.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/core/owl/ObjectPropertyDomainAxiom.java 2013-11-08 09:29:40 UTC (rev 4141)
+++ trunk/components-core/src/main/java/org/dllearner/core/owl/ObjectPropertyDomainAxiom.java 2013-11-11 13:38:04 UTC (rev 4142)
@@ -70,6 +70,12 @@
public void accept(KBElementVisitor visitor) {
visitor.visit(this);
}
+
+ public SubClassAxiom asSubClassOfAxiom(){
+ Description subClass = new ObjectSomeRestriction(getProperty(), new Thing());
+ Description superClass = getDomain();
+ return new SubClassAxiom(subClass, superClass);
+ }
/* (non-Javadoc)
* @see org.dllearner.core.owl.KBElement#toManchesterSyntaxString(java.lang.String, java.util.Map)
Modified: trunk/components-core/src/main/java/org/dllearner/reasoning/OWLAPIReasoner.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/reasoning/OWLAPIReasoner.java 2013-11-08 09:29:40 UTC (rev 4141)
+++ trunk/components-core/src/main/java/org/dllearner/reasoning/OWLAPIReasoner.java 2013-11-11 13:38:04 UTC (rev 4142)
@@ -357,6 +357,7 @@
if (!inconsistentOntology) {
reasoner.precomputeInferences(InferenceType.CLASS_HIERARCHY, InferenceType.CLASS_ASSERTIONS);
} else {
+ reasoner.precomputeInferences(InferenceType.CLASS_HIERARCHY);
throw new ComponentInitException("Inconsistent ontologies.");
}
Modified: trunk/components-core/src/main/java/org/dllearner/reasoning/SPARQLReasoner.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/reasoning/SPARQLReasoner.java 2013-11-08 09:29:40 UTC (rev 4141)
+++ trunk/components-core/src/main/java/org/dllearner/reasoning/SPARQLReasoner.java 2013-11-11 13:38:04 UTC (rev 4142)
@@ -766,6 +766,34 @@
}
return types;
}
+
+ public Set<ObjectProperty> getOWLObjectProperties() {
+ Set<ObjectProperty> types = new HashSet<ObjectProperty>();
+ String query = String.format("SELECT DISTINCT ?p WHERE {?p a <%s>.}",OWL.ObjectProperty.getURI());
+ ResultSet rs = executeSelectQuery(query);
+ QuerySolution qs;
+ while(rs.hasNext()){
+ qs = rs.next();
+ types.add(new ObjectProperty(qs.getResource("p").getURI()));
+ }
+ return types;
+ }
+
+ public SortedSet<ObjectProperty> getOWLObjectProperties(String namespace) {
+ SortedSet<ObjectProperty> types = new TreeSet<ObjectProperty>();
+ String query = "SELECT DISTINCT ?p WHERE {?p a <" + OWL.ObjectProperty.getURI() + ">.";
+ if(namespace != null){
+ query += "FILTER(REGEX(STR(?p),'" + namespace + "'))";
+ }
+ query += "}";
+ ResultSet rs = executeSelectQuery(query);
+ QuerySolution qs;
+ while(rs.hasNext()){
+ qs = rs.next();
+ types.add(new ObjectProperty(qs.getResource("p").getURI()));
+ }
+ return types;
+ }
/**
* Returns a set of classes which are siblings, i.e. on the same level
Modified: trunk/components-core/src/main/java/org/dllearner/reasoning/fuzzydll/FuzzyDLReasonerManager.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/reasoning/fuzzydll/FuzzyDLReasonerManager.java 2013-11-08 09:29:40 UTC (rev 4141)
+++ trunk/components-core/src/main/java/org/dllearner/reasoning/fuzzydll/FuzzyDLReasonerManager.java 2013-11-11 13:38:04 UTC (rev 4142)
@@ -20,25 +20,17 @@
package org.dllearner.reasoning.fuzzydll;
import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringWriter;
-import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
-import java.util.TreeSet;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.semanticweb.owlapi.model.AxiomType;
-import org.semanticweb.owlapi.model.IRI;
import org.semanticweb.owlapi.model.OWLAxiom;
import org.semanticweb.owlapi.model.OWLClass;
import org.semanticweb.owlapi.model.OWLClassExpression;
@@ -69,23 +61,25 @@
import org.semanticweb.owlapi.reasoner.UnsupportedEntailmentTypeException;
import org.semanticweb.owlapi.reasoner.impl.DefaultNode;
import org.semanticweb.owlapi.reasoner.impl.NodeFactory;
-import org.semanticweb.owlapi.reasoner.impl.OWLClassNode;
-import org.semanticweb.owlapi.reasoner.impl.OWLClassNodeSet;
-import org.semanticweb.owlapi.reasoner.impl.OWLNamedIndividualNode;
import org.semanticweb.owlapi.reasoner.impl.OWLNamedIndividualNodeSet;
import org.semanticweb.owlapi.util.SimpleShortFormProvider;
import org.semanticweb.owlapi.util.Version;
-import uk.ac.manchester.cs.owl.owlapi.OWLNamedIndividualImpl;
-
import com.clarkparsia.pellet.owlapiv3.PelletReasoner;
import com.clarkparsia.pellet.owlapiv3.PelletReasonerFactory;
-import fuzzydl.*;
+import fuzzydl.AllInstancesQuery;
+import fuzzydl.Concept;
+import fuzzydl.ConfigReader;
+import fuzzydl.Individual;
+import fuzzydl.KnowledgeBase;
+import fuzzydl.MinInstanceQuery;
+import fuzzydl.Query;
import fuzzydl.exception.FuzzyOntologyException;
import fuzzydl.milp.Solution;
-import fuzzydl.parser.*;
-import fuzzydll.fuzzyowl2fuzzydlparser.*;
+import fuzzydl.parser.Parser;
+import fuzzydll.fuzzyowl2fuzzydlparser.FuzzyOwl2toFuzzyDL;
+import fuzzydll.fuzzyowl2fuzzydlparser.OWLAPI_fuzzyDLObjectParser;
public class FuzzyDLReasonerManager implements OWLReasoner {
@@ -182,10 +176,11 @@
Individual fIndividual = fuzzyKB.getIndividual(shortFormParser.getShortForm((OWLEntity) i));
Concept fConcept = OWLAPI_fuzzyDLObjectParser.getFuzzyDLExpresion(oce);
-
+ try {
+
Query q = new MinInstanceQuery(fConcept, fIndividual);
- try {
+
KnowledgeBase clonedFuzzyKB = fuzzyKB.clone();
// TODO: just for testing, remove
@@ -368,8 +363,8 @@
}
@Override
- public NodeSet<OWLNamedIndividual> getInstances(OWLClassExpression arg0,
- boolean arg1) throws InconsistentOntologyException,
+ public NodeSet<OWLNamedIndividual> getInstances(OWLClassExpression cls,
+ boolean direct) throws InconsistentOntologyException,
ClassExpressionNotInProfileException, FreshEntitiesException,
ReasonerInterruptedException, TimeOutException {
@@ -379,34 +374,50 @@
// added by Josue in order to use fuzzyDL and not Pellet to answer this OWLAPI method
boolean differentInstances = false;
Solution localQuerySolution = null;
- NodeSet<OWLNamedIndividual> owlApiOutput = crispReasoner.getInstances(arg0, arg1);
+ //get all instances using OWL API
+ NodeSet<OWLNamedIndividual> owlApiOutput = crispReasoner.getInstances(cls, direct);
Set<OWLNamedIndividual> owlApiInstances = owlApiOutput.getFlattened();
- for (Individual fuzzyIndividual : fuzzyKB.individuals.values()) {
- // TODO this "query process" is repeated several times --> create a (private) method
- Query localQuery = new MinInstanceQuery(OWLAPI_fuzzyDLObjectParser.getFuzzyDLExpresion(arg0), fuzzyIndividual);
- try {
- KnowledgeBase clonedFuzzyKB = fuzzyKB.clone();
- localQuerySolution = localQuery.solve(clonedFuzzyKB);
- if (!localQuerySolution.isConsistentKB()){
- System.err.println("Fuzzy KB is inconsistent.");
- System.err.println("This may be a fuzzyDL reasoner bug. Press enter to continue.");
- System.err.println("concept: " + arg0 + " individual: " + fuzzyIndividual);
- Scanner sc = new Scanner(System.in);
- sc.nextLine();
+ //get all instances using FuzzyDL
+ try {
+ Concept fuzzyConcept = OWLAPI_fuzzyDLObjectParser.getFuzzyDLExpresion(cls);
+ AllInstancesQuery query = new AllInstancesQuery(fuzzyConcept);
+ Solution solution = query.solve(fuzzyKB);
+ if(solution.isConsistentKB() && solution.getSolution() == 0){
+ List<Individual> individuals = query.getIndividuals();
+ for (Individual individual : individuals) {
+
}
- } catch (Exception e) {
- e.printStackTrace();
}
- if (localQuerySolution.getSolution() == 0) {
- for (OWLNamedIndividual owlApiSingleInstance : owlApiOutput.getFlattened()) {
- String a = baseURI.concat(fuzzyIndividual.toString());
- String b = owlApiSingleInstance.toStringID();
- if (a.equals(b)) {
- owlApiInstances.remove(owlApiSingleInstance);
- differentInstances = true; }
- }
- }
+
+ } catch (FuzzyOntologyException e1) {
+ e1.printStackTrace();
}
+// for (Individual fuzzyIndividual : fuzzyKB.) {
+// // TODO this "query process" is repeated several times --> create a (private) method
+// Query localQuery = new MinInstanceQuery(OWLAPI_fuzzyDLObjectParser.getFuzzyDLExpresion(cls), fuzzyIndividual);
+// try {
+// KnowledgeBase clonedFuzzyKB = fuzzyKB.clone();
+// localQuerySolution = localQuery.solve(clonedFuzzyKB);
+// if (!localQuerySolution.isConsistentKB()){
+// System.err.println("Fuzzy KB is inconsistent.");
+// System.err.println("This may be a fuzzyDL reasoner bug. Press enter to continue.");
+// System.err.println("concept: " + cls + " individual: " + fuzzyIndividual);
+// Scanner sc = new Scanner(System.in);
+// sc.nextLine();
+// }
+// } catch (Exception e) {
+// e.printStackTrace();
+// }
+// if (localQuerySolution.getSolution() == 0) {
+// for (OWLNamedIndividual owlApiSingleInstance : owlApiOutput.getFlattened()) {
+// String a = baseURI.concat(fuzzyIndividual.toString());
+// String b = owlApiSingleInstance.toStringID();
+// if (a.equals(b)) {
+// owlApiInstances.remove(owlApiSingleInstance);
+// differentInstances = true; }
+// }
+// }
+// }
if (differentInstances){
Set<Node<OWLNamedIndividual>> instances = new HashSet<Node<OWLNamedIndividual>>();
Modified: trunk/components-core/src/main/java/org/dllearner/utilities/datastructures/PrefixTrie.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/utilities/datastructures/PrefixTrie.java 2013-11-08 09:29:40 UTC (rev 4141)
+++ trunk/components-core/src/main/java/org/dllearner/utilities/datastructures/PrefixTrie.java 2013-11-11 13:38:04 UTC (rev 4142)
@@ -150,7 +150,7 @@
* @return A Map mapping each prefix to its corresponding value.
*/
public Map<String, T> toMap() {
- Map<String, T> map = com.google.common.collect.Maps.newLinkedHashMap();
+ Map<String, T> map = com.google.common.collect.Maps.newTreeMap();
addEntries(root, new StringBuilder(), map);
return map;
}
Modified: trunk/components-core/src/main/java/org/dllearner/utilities/owl/OWLClassExpressionToSPARQLConverter.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/utilities/owl/OWLClassExpressionToSPARQLConverter.java 2013-11-08 09:29:40 UTC (rev 4141)
+++ trunk/components-core/src/main/java/org/dllearner/utilities/owl/OWLClassExpressionToSPARQLConverter.java 2013-11-11 13:38:04 UTC (rev 4142)
@@ -348,13 +348,16 @@
sparql += triple(variables.peek(), propertyExpression.getNamedProperty(), objectVariable);
}
OWLClassExpression filler = ce.getFiller();
- if(filler.isAnonymous()){
- variables.push(objectVariable);
- filler.accept(this);
- variables.pop();
- } else {
- sparql += triple(objectVariable, "a", filler.asOWLClass());
- }
+ variables.push(objectVariable);
+ filler.accept(this);
+ variables.pop();
+// if(filler.isAnonymous()){
+// variables.push(objectVariable);
+// filler.accept(this);
+// variables.pop();
+// } else {
+// sparql += triple(objectVariable, "a", filler.asOWLClass());
+// }
}
Modified: trunk/components-core/src/test/java/org/dllearner/algorithms/isle/CrossValidation.java
===================================================================
--- trunk/components-core/src/test/java/org/dllearner/algorithms/isle/CrossValidation.java 2013-11-08 09:29:40 UTC (rev 4141)
+++ trunk/components-core/src/test/java/org/dllearner/algorithms/isle/CrossValidation.java 2013-11-11 13:38:04 UTC (rev 4142)
@@ -29,20 +29,25 @@
import java.util.Set;
import java.util.TreeSet;
+import org.dllearner.core.AbstractCELA;
import org.dllearner.core.AbstractLearningProblem;
+import org.dllearner.core.AbstractReasonerComponent;
import org.dllearner.core.ComponentInitException;
-import org.dllearner.core.AbstractCELA;
-import org.dllearner.core.AbstractReasonerComponent;
import org.dllearner.core.owl.Description;
import org.dllearner.core.owl.Individual;
import org.dllearner.learningproblems.Heuristics;
import org.dllearner.learningproblems.PosNegLP;
import org.dllearner.learningproblems.PosOnlyLP;
+import org.dllearner.utilities.Files;
import org.dllearner.utilities.Helper;
import org.dllearner.utilities.datastructures.Datastructures;
import org.dllearner.utilities.statistics.Stat;
-import org.dllearner.utilities.Files;
+import com.google.common.base.Charsets;
+import com.google.common.hash.HashCode;
+import com.google.common.hash.HashFunction;
+import com.google.common.hash.Hashing;
+
/**
* Performs cross validation for the given problem. Supports
* k-fold cross-validation and leave-one-out cross-validation.
@@ -69,6 +74,8 @@
protected Stat testingCompletenessStat = new Stat();
protected Stat testingCorrectnessStat = new Stat();
+ static HashFunction hf = Hashing.crc32();
+
public CrossValidation() {
}
@@ -90,7 +97,7 @@
posExamples = ((PosNegLP)lp).getPositiveExamples();
negExamples = ((PosNegLP)lp).getNegativeExamples();
} else if(lp instanceof PosOnlyLP){
- posExamples = ((PosNegLP)lp).getPositiveExamples();
+ posExamples = ((PosOnlyLP)lp).getPositiveExamples();
negExamples = new HashSet<Individual>();
} else {
throw new IllegalArgumentException("Only PosNeg and PosOnly learning problems are supported");
@@ -184,7 +191,7 @@
int trainingCorrectNegClassified = getCorrectNegClassified(rs, concept, trainingSetsNeg.get(currFold));
int trainingCorrectExamples = trainingCorrectPosClassified + trainingCorrectNegClassified;
double trainingAccuracy = 100*((double)trainingCorrectExamples/(trainingSetsPos.get(currFold).size()+
- trainingSetsNeg.get(currFold).size()));
+ trainingSetsNeg.get(currFold).size())); HashFunction hf = Hashing.md5();
accuracyTraining.addNumber(trainingAccuracy);
// calculate test accuracies
int correctPosClassified = getCorrectPosClassified(rs, concept, testSetsPos.get(currFold));
@@ -308,5 +315,18 @@
public Stat getfMeasureTraining() {
return fMeasureTraining;
}
-
+
+ /**
+ * Returns for a given URI the fold number to which the URI is supposed to belong to.
+ * @param uri
+ * @param nrOfFolds
+ * @return
+ */
+ public static int belongsToFoldNumber(String uri, int nrOfFolds){
+ HashCode hc = hf.newHasher()
+ .putString(uri, Charsets.UTF_8)
+ .hash();
+ int fold = hc.asInt() % nrOfFolds;
+ return fold;
+ }
}
Modified: trunk/components-core/src/test/java/org/dllearner/algorithms/isle/Experiment.java
===================================================================
--- trunk/components-core/src/test/java/org/dllearner/algorithms/isle/Experiment.java 2013-11-08 09:29:40 UTC (rev 4141)
+++ trunk/components-core/src/test/java/org/dllearner/algorithms/isle/Experiment.java 2013-11-11 13:38:04 UTC (rev 4142)
@@ -4,15 +4,15 @@
package org.dllearner.algorithms.isle;
import java.io.File;
-import java.io.IOException;
-import java.net.URL;
-import java.text.DecimalFormat;
+import java.util.Collections;
import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.SortedSet;
import org.dllearner.algorithms.celoe.CELOE;
-import org.dllearner.algorithms.isle.index.RemoteDataProvider;
import org.dllearner.algorithms.isle.index.TextDocument;
import org.dllearner.algorithms.isle.index.semantic.SemanticIndex;
import org.dllearner.algorithms.isle.index.semantic.simple.SimpleSemanticIndex;
@@ -21,22 +21,28 @@
import org.dllearner.algorithms.isle.metrics.RelevanceUtils;
import org.dllearner.core.AbstractReasonerComponent;
import org.dllearner.core.ComponentInitException;
+import org.dllearner.core.EvaluatedDescription;
import org.dllearner.core.KnowledgeSource;
+import org.dllearner.core.owl.Description;
import org.dllearner.core.owl.Entity;
+import org.dllearner.core.owl.Individual;
+import org.dllearner.core.owl.Intersection;
import org.dllearner.core.owl.NamedClass;
+import org.dllearner.core.owl.Thing;
import org.dllearner.kb.OWLAPIOntology;
import org.dllearner.learningproblems.ClassLearningProblem;
+import org.dllearner.learningproblems.PosOnlyLP;
import org.dllearner.reasoning.FastInstanceChecker;
-import org.dllearner.utilities.Helper;
-import org.semanticweb.owlapi.apibinding.OWLManager;
-import org.semanticweb.owlapi.model.IRI;
+import org.dllearner.refinementoperators.CustomStartRefinementOperator;
+import org.dllearner.refinementoperators.LengthLimitedRefinementOperator;
+import org.dllearner.refinementoperators.OperatorInverter;
+import org.dllearner.refinementoperators.ReasoningBasedRefinementOperator;
+import org.dllearner.refinementoperators.RhoDRDown;
import org.semanticweb.owlapi.model.OWLClass;
import org.semanticweb.owlapi.model.OWLOntology;
-import org.semanticweb.owlapi.model.OWLOntologyManager;
-import com.google.common.base.Charsets;
+import com.clarkparsia.sparqlowl.parser.antlr.SparqlOwlParser.whereClause_return;
import com.google.common.collect.Sets;
-import com.google.common.io.Files;
/**
* Experimental setup:
@@ -55,7 +61,7 @@
*/
private final boolean LEAVE_ONE_OUT = false;
- private ClassLearningProblem lp;
+ private PosOnlyLP lp;
private RelevanceMetric relevance;
private AbstractReasonerComponent reasoner;
@@ -65,6 +71,7 @@
private Set<TextDocument> documents;
private boolean initialized = false;
+ private RhoDRDown operator;
protected abstract OWLOntology getOntology();
@@ -87,7 +94,15 @@
reasoner = new FastInstanceChecker(ks);
reasoner.init();
// set learning problem
- lp = new ClassLearningProblem(reasoner);
+// lp = new ClassLearningProblem(reasoner);
+ lp = new PosOnlyLP(reasoner);
+
+ //refinement operator for getting a start class
+ operator = new RhoDRDown();
+ if(operator instanceof ReasoningBasedRefinementOperator) {
+ ((ReasoningBasedRefinementOperator)operator).setReasoner(reasoner);
+ }
+ operator.init();
} catch (ComponentInitException e) {
e.printStackTrace();
}
@@ -124,6 +139,73 @@
}
}
+ private Description getStartClass(NamedClass cls, boolean isEquivalenceProblem, boolean reuseExistingDescription){
+ //get instances of class to describe
+ SortedSet<Individual> individuals = reasoner.getIndividuals(cls);
+
+ //set start class to owl:Thing first
+ Description startClass = Thing.instance;
+ if(operator instanceof CustomStartRefinementOperator) {
+ ((CustomStartRefinementOperator)operator).setStartClass(startClass);
+ }
+ if(isEquivalenceProblem) {
+ Set<Description> existingDefinitions = reasoner.getAssertedDefinitions(cls);
+ if(reuseExistingDescription && (existingDefinitions.size() > 0)) {
+ // the existing definition is reused, which in the simplest case means to
+ // use it as a start class or, if it is already too specific, generalise it
+
+ // pick the longest existing definition as candidate
+ Description existingDefinition = null;
+ int highestLength = 0;
+ for(Description exDef : existingDefinitions) {
+ if(exDef.getLength() > highestLength) {
+ existingDefinition = exDef;
+ highestLength = exDef.getLength();
+ }
+ }
+
+ LinkedList<Description> startClassCandidates = new LinkedList<Description>();
+ startClassCandidates.add(existingDefinition);
+ // hack for RhoDRDown
+ if(operator instanceof RhoDRDown) {
+ ((RhoDRDown)operator).setDropDisjuncts(true);
+ }
+ LengthLimitedRefinementOperator upwardOperator = (LengthLimitedRefinementOperator) new OperatorInverter(operator);
+
+ // use upward refinement until we find an appropriate start class
+ boolean startClassFound = false;
+ Description candidate;
+ do {
+ candidate = startClassCandidates.pollFirst();
+ SortedSet<Individual> candidateIndividuals = reasoner.getIndividuals(candidate);
+ double recall = Sets.intersection(individuals, candidateIndividuals).size() / (double)individuals.size();
+ if(recall < 1.0) {
+ // add upward refinements to list
+ Set<Description> refinements = upwardOperator.refine(candidate, candidate.getLength());
+ LinkedList<Description> refinementList = new LinkedList<Description>(refinements);
+// Collections.reverse(refinementList);
+// System.out.println("list: " + refinementList);
+ startClassCandidates.addAll(refinementList);
+// System.out.println("candidates: " + startClassCandidates);
+ } else {
+ startClassFound = true;
+ }
+ } while(!startClassFound);
+ startClass = candidate;
+ } else {
+ Set<Description> superClasses = reasoner.getClassHierarchy().getSuperClasses(cls);
+ if(superClasses.size() > 1) {
+ startClass = new Intersection(new LinkedList<Description>(superClasses));
+ } else if(superClasses.size() == 1){
+ startClass = (Description) superClasses.toArray()[0];
+ } else {
+ startClass = Thing.instance;
+ }
+ }
+ }
+ return startClass;
+ }
+
/**
* Run the experiment on the given class.
* @param cls
@@ -132,26 +214,56 @@
public void run(NamedClass cls) throws ComponentInitException {
initIfNecessary();
- lp.setClassToDescribe(cls);
+// lp.setClassToDescribe(cls);
+ //get the positive examples, here just the instances of the class to describe
+ SortedSet<Individual> individuals = reasoner.getIndividuals(cls);
+ lp.setPositiveExamples(individuals);
lp.init();
+ //get the start class for the learning algorithms
+ Description startClass = getStartClass(cls, true, true);
+
Map<Entity, Double> entityRelevance = RelevanceUtils.getRelevantEntities(cls, ontology, relevance);
NLPHeuristic heuristic = new NLPHeuristic(entityRelevance);
+ heuristic.setStartNodeBonus(100);
+ ClassLearningProblem clp = new ClassLearningProblem(reasoner);
+ clp.setClassToDescribe(cls);
+ clp.init();
+
+ System.out.println(reasoner.getObjectProperties());
+
+ RhoDRDown rop = new RhoDRDown();
+ rop.setReasoner(reasoner);
+ rop.setUseNegation(false);
+ rop.init();
+
// perform cross validation with ISLE
- ISLE isle = new ISLE(lp, reasoner);
+ ISLE isle = new ISLE(clp, reasoner);
isle.setHeuristic(heuristic);
-// isle.setSearchTreeFile(testFolder + "searchTreeISLE.txt");
-// isle.setWriteSearchTree(true);
+ isle.setMaxNrOfResults(30);
+ isle.setOperator(rop);
+// isle.setStartClass(startClass);
+ new File(testFolder).mkdirs();
+ isle.setSearchTreeFile(testFolder + "searchTreeISLE.txt");
+ isle.setWriteSearchTree(true);
// isle.setReplaceSearchTree(true);
- isle.setTerminateOnNoiseReached(true);
+// isle.setTerminateOnNoiseReached(true);
+ isle.setIgnoredConcepts(Collections.singleton(cls));
+ isle.setReplaceSearchTree(true);
isle.init();
+ isle.start();System.exit(1);
+ List<? extends EvaluatedDescription> currentlyBestDescriptions = isle.getCurrentlyBestEvaluatedDescriptions(20);
+ for (EvaluatedDescription description : currentlyBestDescriptions) {
+ System.out.println(description);
+ }
CrossValidation crossValidationISLE = new CrossValidation(isle, lp, reasoner, FOLDS, LEAVE_ONE_OUT);
// perform cross validation with CELOE
CELOE celoe = new CELOE(lp, reasoner);
-// celoe.setSearchTreeFile(testFolder + "searchTreeCELOE.txt");
-// celoe.setWriteSearchTree(true);
+ celoe.setStartClass(startClass);
+ celoe.setSearchTreeFile(testFolder + "searchTreeCELOE.txt");
+ celoe.setWriteSearchTree(true);
// celoe.setReplaceSearchTree(true);
celoe.setTerminateOnNoiseReached(true);
celoe.init();
Modified: trunk/components-core/src/test/java/org/dllearner/algorithms/isle/SemanticBibleExperiment.java
===================================================================
--- trunk/components-core/src/test/java/org/dllearner/algorithms/isle/SemanticBibleExperiment.java 2013-11-08 09:29:40 UTC (rev 4141)
+++ trunk/components-core/src/test/java/org/dllearner/algorithms/isle/SemanticBibleExperiment.java 2013-11-11 13:38:04 UTC (rev 4142)
@@ -10,6 +10,7 @@
import java.util.HashSet;
import java.util.Set;
+import org.aksw.jena_sparql_api.model.QueryExecutionFactoryModel;
import org.dllearner.algorithms.isle.index.RemoteDataProvider;
import org.dllearner.algorithms.isle.index.TextDocument;
import org.dllearner.core.owl.NamedClass;
@@ -22,6 +23,9 @@
import com.google.common.base.Charsets;
import com.google.common.collect.Sets;
import com.google.common.io.Files;
+import com.hp.hpl.jena.query.ResultSetFormatter;
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.rdf.model.ModelFactory;
/**
* @author Lorenz Buehmann
@@ -41,6 +45,11 @@
OWLOntology mergedOntology = man.createOntology(IRI.create("http://semanticbible.com/merged.owl"));
man.addAxioms(mergedOntology, schema.getAxioms());
man.addAxioms(mergedOntology, instances.getAxioms());
+// Model model = ModelFactory.createDefaultModel();
+// model.read("http://www.semanticbible.com/2006/11/NTNames.owl");
+// model.read("http://www.semanticbible.com/2006/11/NTN-individuals.owl");
+// QueryExecutionFactoryModel qef = new QueryExecutionFactoryModel(model);
+// System.out.println(ResultSetFormatter.asText(qef.createQueryExecution("SELECT ?s ?p WHERE {?s a <http://semanticbible.org/ns/2006/NTNames#Woman>. ?s ?p ?o.}").execSelect()));
return mergedOntology;
} catch (OWLOntologyCreationException e) {
e.printStackTrace();
Modified: trunk/components-core/src/test/java/org/dllearner/algorithms/qtl/LGGTest.java
===================================================================
--- trunk/components-core/src/test/java/org/dllearner/algorithms/qtl/LGGTest.java 2013-11-08 09:29:40 UTC (rev 4141)
+++ trunk/components-core/src/test/java/org/dllearner/algorithms/qtl/LGGTest.java 2013-11-11 13:38:04 UTC (rev 4142)
@@ -21,6 +21,7 @@
import java.io.File;
import java.io.FileInputStream;
+import java.net.URL;
import java.util.ArrayList;
import java.util.List;
@@ -34,6 +35,9 @@
import org.dllearner.algorithms.qtl.operations.lgg.LGGGenerator;
import org.dllearner.algorithms.qtl.operations.lgg.LGGGeneratorImpl;
import org.dllearner.algorithms.qtl.operations.lgg.NoiseSensitiveLGG;
+import org.dllearner.kb.sparql.ConciseBoundedDescriptionGenerator;
+import org.dllearner.kb.sparql.ConciseBoundedDescriptionGeneratorImpl;
+import org.dllearner.kb.sparql.SparqlEndpoint;
import org.junit.Assert;
import org.junit.Test;
@@ -427,6 +431,31 @@
System.out.println("Covered negatives:" + coveredNegatives);
}
}
+
+ @Test
+ public void testTCGA() throws Exception{
+ URL url = new URL("http://vmlion14.deri.ie/node43/8080/sparql");
+ SparqlEndpoint endpoint = new SparqlEndpoint(url);
+ List<String> posExamples = Lists.newArrayList("http://tcga.deri.ie/TCGA-BI-A0VS","http://tcga.deri.ie/TCGA-BI-A20A");
+
+ ConciseBoundedDescriptionGenerator cbdGen = new ConciseBoundedDescriptionGeneratorImpl(endpoint);
+
+ QueryTreeFactory<String> queryTreeFactory = new QueryTreeFactoryImpl();
+
+ List<QueryTree<String>> posExampleTrees = new ArrayList<QueryTree<String>>();
+ for (String ex : posExamples) {
+ Model cbd = cbdGen.getConciseBoundedDescription(ex, 0);
+ System.out.println(cbd.size());
+ QueryTreeImpl<String> tree = queryTreeFactory.getQueryTree(ex, cbd);
+ posExampleTrees.add(tree);
+ }
+
+ NoiseSensitiveLGG<String> lggGenerator = new NoiseSensitiveLGG<String>();
+ List<EvaluatedQueryTree<String>> lggs = lggGenerator.computeLGG(posExampleTrees);
+ for (EvaluatedQueryTree<String> lgg : lggs) {
+ System.out.println(lgg);
+ }
+ }
}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
