Menu
▾
▴
[DL-Learner SVN] SF.net SVN: dl-learner:[2750] trunk/components-ext
|
From: <lor...@us...> - 2011-04-05 08:29:54
|
Revision: 2750
http://dl-learner.svn.sourceforge.net/dl-learner/?rev=2750&view=rev
Author: lorenz_b
Date: 2011-04-05 08:29:44 +0000 (Tue, 05 Apr 2011)
Log Message:
-----------
Migrated test cases from sparql-query-generator module.
Modified Paths:
--------------
trunk/components-ext/pom.xml
trunk/components-ext/src/main/java/org/dllearner/algorithm/qtl/QTL.java
trunk/components-ext/src/main/java/org/dllearner/algorithm/tbsl/learning/SPARQLTemplateBasedLearner.java
Added Paths:
-----------
trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/
trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/GeneralisationTest.java
trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/LGGTest.java
trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/ModelCreationTest.java
trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/NBRTest.java
trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/TreeSubsumptionTest.java
Modified: trunk/components-ext/pom.xml
===================================================================
--- trunk/components-ext/pom.xml 2011-04-04 18:17:00 UTC (rev 2749)
+++ trunk/components-ext/pom.xml 2011-04-05 08:29:44 UTC (rev 2750)
@@ -29,9 +29,6 @@
<dependency>
<groupId>com.jamonapi</groupId>
<artifactId>jamon</artifactId>
- <version>2.7</version>
- <type>jar</type>
- <scope>compile</scope>
</dependency>
<dependency>
<groupId>org.apache.solr</groupId>
@@ -86,5 +83,18 @@
<type>jar</type>
<scope>compile</scope>
</dependency>
+ <dependency>
+ <groupId>com.hp.hpl.jena</groupId>
+ <artifactId>jena</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>com.hp.hpl.jena</groupId>
+ <artifactId>arq</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
</dependencies>
</project>
Modified: trunk/components-ext/src/main/java/org/dllearner/algorithm/qtl/QTL.java
===================================================================
--- trunk/components-ext/src/main/java/org/dllearner/algorithm/qtl/QTL.java 2011-04-04 18:17:00 UTC (rev 2749)
+++ trunk/components-ext/src/main/java/org/dllearner/algorithm/qtl/QTL.java 2011-04-05 08:29:44 UTC (rev 2750)
@@ -77,9 +77,11 @@
negExampleTrees.addAll(getQueryTrees(negExamples));
lgg = lggGenerator.getLGG(posExampleTrees);
+ System.out.println(lgg.getStringRepresentation());
if(queryTreeFilter != null){
lgg = queryTreeFilter.getFilteredQueryTree(lgg);
}
+ System.out.println(lgg.getStringRepresentation());
if(coversNegativeQueryTree(lgg)){
throw new QTLException("Could not learn SPARQL query. Reason: LGG covers negative tree.");
Modified: trunk/components-ext/src/main/java/org/dllearner/algorithm/tbsl/learning/SPARQLTemplateBasedLearner.java
===================================================================
--- trunk/components-ext/src/main/java/org/dllearner/algorithm/tbsl/learning/SPARQLTemplateBasedLearner.java 2011-04-04 18:17:00 UTC (rev 2749)
+++ trunk/components-ext/src/main/java/org/dllearner/algorithm/tbsl/learning/SPARQLTemplateBasedLearner.java 2011-04-05 08:29:44 UTC (rev 2750)
@@ -23,6 +23,7 @@
import org.dllearner.algorithm.tbsl.sparql.SlotType;
import org.dllearner.algorithm.tbsl.sparql.Template;
import org.dllearner.algorithm.tbsl.templator.Templator;
+import org.dllearner.core.LearningAlgorithm;
import org.dllearner.kb.sparql.ExtractionDBCache;
import org.dllearner.kb.sparql.SparqlEndpoint;
import org.dllearner.kb.sparql.SparqlQuery;
@@ -36,7 +37,7 @@
import com.jamonapi.Monitor;
import com.jamonapi.MonitorFactory;
-public class SPARQLTemplateBasedLearner {
+public class SPARQLTemplateBasedLearner implements LearningAlgorithm{
private static final Logger logger = Logger.getLogger(SPARQLTemplateBasedLearner.class);
private Monitor mon = MonitorFactory.getTimeMonitor("stbl");
@@ -84,9 +85,11 @@
modelGenenerator = new ModelGenerator(endpoint, predicateFilters);
}
- public void learnSPARQLQueries(String question){
+ public void setQuestion(String question){
this.question = question;
-
+ }
+
+ private void learnSPARQLQueries(){
//generate SPARQL query templates
logger.info("Generating SPARQL query templates...");
mon.start();
@@ -365,14 +368,20 @@
* @throws MalformedURLException
*/
public static void main(String[] args) throws MalformedURLException {
+ String question = "Give me all soccer clubs in Premier League";//Give me all countries in Europe
SPARQLTemplateBasedLearner learner = new SPARQLTemplateBasedLearner();
SparqlEndpoint endpoint = new SparqlEndpoint(new URL("http://db0.aksw.org:8999/sparql"),
Collections.<String>singletonList("http://dbpedia.org"), Collections.<String>emptyList());
learner.setEndpoint(endpoint);
-// learner.learnSPARQLQueries("Give me all countries in Europe");
- learner.learnSPARQLQueries("Give me all soccer clubs in Premier League");
+ learner.setQuestion(question);
+ learner.start();
}
+
+ @Override
+ public void start() {
+ learnSPARQLQueries();
+ }
}
Added: trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/GeneralisationTest.java
===================================================================
--- trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/GeneralisationTest.java (rev 0)
+++ trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/GeneralisationTest.java 2011-04-05 08:29:44 UTC (rev 2750)
@@ -0,0 +1,83 @@
+package org.dllearner.algorithm.qtl;
+
+import org.dllearner.algorithm.qtl.datastructures.QueryTree;
+import org.dllearner.algorithm.qtl.impl.QueryTreeFactoryImpl;
+import org.dllearner.algorithm.qtl.operations.Generalisation;
+import org.junit.Test;
+
+import com.hp.hpl.jena.query.Query;
+import com.hp.hpl.jena.query.QueryExecution;
+import com.hp.hpl.jena.query.QueryExecutionFactory;
+import com.hp.hpl.jena.query.QueryFactory;
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.rdf.model.ModelFactory;
+
+public class GeneralisationTest {
+
+ private static final int RECURSION_DEPTH = 2;
+ private int maxModelSizePerExample = 3000;
+ private final static int LIMIT = 1000;
+ private final static int OFFSET = 1000;
+ private static final String ENDPOINT_URL = "http://dbpedia.org/sparql";
+
+ @Test
+ public void generalisationTest1(){
+ String resource = "http://dbpedia.org/resource/Leipzig";
+
+ Generalisation<String> gen = new Generalisation<String>();
+ Model model = getModelForExample(resource, maxModelSizePerExample);
+ QueryTree<String> tree = new QueryTreeFactoryImpl().getQueryTree(resource, model);
+ System.out.println(tree.toSPARQLQueryString());
+ QueryTree<String> genTree = gen.generalise(tree);
+ String query = genTree.toSPARQLQueryString();
+ System.out.println(query);
+ }
+
+ private Model getModelForExample(String example, int maxSize){
+ Query query = makeConstructQuery(example, LIMIT, 0);
+ QueryExecution qexec = QueryExecutionFactory.sparqlService(ENDPOINT_URL, query);
+ Model all = ModelFactory.createDefaultModel();
+ Model model = qexec.execConstruct();
+ all.add(model);
+ qexec.close();
+ int i = 1;
+ while(model.size() != 0 && all.size() < maxSize){
+ query = makeConstructQuery(example, LIMIT, i * OFFSET);
+ qexec = QueryExecutionFactory.sparqlService(ENDPOINT_URL, query);
+ model = qexec.execConstruct();
+ all.add(model);
+ qexec.close();
+ i++;
+ }
+ return all;
+ }
+
+ private Query makeConstructQuery(String example, int limit, int offset){
+ StringBuilder sb = new StringBuilder();
+ sb.append("CONSTRUCT {\n");
+ sb.append("<").append(example).append("> ").append("?p0 ").append("?o0").append(".\n");
+ for(int i = 1; i < RECURSION_DEPTH; i++){
+ sb.append("?o").append(i-1).append(" ").append("?p").append(i).append(" ").append("?o").append(i).append(".\n");
+ }
+ sb.append("}\n");
+ sb.append("WHERE {\n");
+ sb.append("<").append(example).append("> ").append("?p0 ").append("?o0").append(".\n");
+ for(int i = 1; i < RECURSION_DEPTH; i++){
+ sb.append("?o").append(i-1).append(" ").append("?p").append(i).append(" ").append("?o").append(i).append(".\n");
+ }
+
+ sb.append("FILTER (!regex (?p0, \"http://dbpedia.org/property/wikiPage\") && !regex(?p1, \"http://dbpedia.org/property/wikiPage\"))");
+ sb.append("}\n");
+ sb.append("ORDER BY ");
+ for(int i = 0; i < RECURSION_DEPTH; i++){
+ sb.append("?p").append(i).append(" ").append("?o").append(i).append(" ");
+ }
+ sb.append("\n");
+ sb.append("LIMIT ").append(limit).append("\n");
+ sb.append("OFFSET ").append(offset);
+ Query query = QueryFactory.create(sb.toString());
+ System.out.println(sb.toString());
+ return query;
+ }
+
+}
Added: trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/LGGTest.java
===================================================================
--- trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/LGGTest.java (rev 0)
+++ trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/LGGTest.java 2011-04-05 08:29:44 UTC (rev 2750)
@@ -0,0 +1,232 @@
+/**
+ * Copyright (C) 2007-2010, Jens Lehmann
+ *
+ * This file is part of DL-Learner.
+ *
+ * DL-Learner is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * DL-Learner is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package org.dllearner.algorithm.qtl;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+import org.apache.log4j.Logger;
+import org.dllearner.algorithm.qtl.datastructures.QueryTree;
+import org.dllearner.algorithm.qtl.datastructures.impl.QueryTreeImpl;
+import org.dllearner.algorithm.qtl.examples.DBpediaExample;
+import org.dllearner.algorithm.qtl.examples.LinkedGeoDataExample;
+import org.dllearner.algorithm.qtl.impl.QueryTreeFactoryImpl;
+import org.dllearner.algorithm.qtl.operations.lgg.LGGGenerator;
+import org.dllearner.algorithm.qtl.operations.lgg.LGGGeneratorImpl;
+import org.dllearner.algorithm.qtl.util.ModelGenerator;
+import org.dllearner.algorithm.qtl.util.ModelGenerator.Strategy;
+import org.dllearner.kb.sparql.ExtractionDBCache;
+import org.dllearner.kb.sparql.SparqlEndpoint;
+import org.dllearner.kb.sparql.SparqlQuery;
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.hp.hpl.jena.query.ResultSet;
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.vocabulary.OWL;
+import com.hp.hpl.jena.vocabulary.RDF;
+import com.hp.hpl.jena.vocabulary.RDFS;
+import com.jamonapi.MonitorFactory;
+
+/**
+ *
+ * @author Lorenz Bühmann
+ *
+ */
+public class LGGTest {
+
+ private static final Logger logger = Logger.getLogger(LGGTest.class);
+
+ @Test
+ public void testLGGWithDBpediaExample(){
+ QueryTreeFactory<String> factory = new QueryTreeFactoryImpl();
+
+ List<QueryTree<String>> posExampleTrees = DBpediaExample.getPosExampleTrees();
+
+ int cnt = 1;
+ for(QueryTree<String> tree : posExampleTrees){
+ System.out.println("TREE " + cnt);
+ tree.dump();
+ System.out.println("-----------------------------");
+ cnt++;
+ }
+
+ LGGGenerator<String> lggGenerator = new LGGGeneratorImpl<String>();
+ QueryTree<String> lgg = lggGenerator.getLGG(posExampleTrees);
+
+ System.out.println("LGG");
+ lgg.dump();
+
+ QueryTreeImpl<String> tree = factory.getQueryTree("?");
+ QueryTreeImpl<String> subTree1 = new QueryTreeImpl<String>("?");
+ subTree1.addChild(new QueryTreeImpl<String>("?"), "leaderParty");
+ subTree1.addChild(new QueryTreeImpl<String>("?"), "population");
+ subTree1.addChild(new QueryTreeImpl<String>("Germany"), "locatedIn");
+ tree.addChild(subTree1, "birthPlace");
+ tree.addChild(new QueryTreeImpl<String>("?"), RDFS.label.toString());
+ QueryTreeImpl<String> subTree2 = new QueryTreeImpl<String>("Person");
+ subTree2.addChild(new QueryTreeImpl<String>(OWL.Thing.toString()), RDFS.subClassOf.toString());
+ tree.addChild(subTree2, RDF.type.toString());
+ QueryTreeImpl<String> subTree3 = new QueryTreeImpl<String>("?");
+ QueryTreeImpl<String> subSubTree = new QueryTreeImpl<String>("Person");
+ subSubTree.addChild(new QueryTreeImpl<String>(OWL.Thing.toString()), RDFS.subClassOf.toString());
+ subTree3.addChild(subSubTree, RDFS.subClassOf.toString());
+ tree.addChild(subTree3, RDF.type.toString());
+
+ Assert.assertTrue(lgg.isSameTreeAs(tree));
+
+ System.out.println(tree.toSPARQLQueryString());
+
+ }
+
+ @Test
+ public void testLGGWithLinkedGeoDataExample(){
+ QueryTreeFactory<String> factory = new QueryTreeFactoryImpl();
+
+ List<QueryTree<String>> posExampleTrees = LinkedGeoDataExample.getPosExampleTrees();
+
+ int cnt = 1;
+ for(QueryTree<String> tree : posExampleTrees){
+ System.out.println("TREE " + cnt);
+ tree.dump();
+ System.out.println("-----------------------------");
+ cnt++;
+ }
+
+ LGGGenerator<String> lggGenerator = new LGGGeneratorImpl<String>();
+ QueryTree<String> lgg = lggGenerator.getLGG(posExampleTrees);
+
+ System.out.println("LGG");
+ lgg.dump();
+
+ QueryTreeImpl<String> tree = factory.getQueryTree("?");
+ QueryTreeImpl<String> subTree = new QueryTreeImpl<String>("lgdo:Aerodome");
+ subTree.addChild(new QueryTreeImpl<String>("lgdo:Aeroway"), RDFS.subClassOf.toString());
+ tree.addChild(subTree, RDF.type.toString());
+ tree.addChild(new QueryTreeImpl<String>("?"), RDFS.label.toString());
+ tree.addChild(new QueryTreeImpl<String>("?"), "geo:long");
+ tree.addChild(new QueryTreeImpl<String>("?"), "geo:lat");
+ tree.addChild(new QueryTreeImpl<String>("?"), "georss:point");
+ tree.addChild(new QueryTreeImpl<String>("?"), "lgdp:icao");
+
+ Assert.assertTrue(lgg.isSameTreeAs(tree));
+
+ System.out.println(tree.toSPARQLQueryString());
+
+ }
+
+// @Test
+ public void performanceTest(){
+ int recursionDepth = 3;
+ int limit = 100;
+ SparqlEndpoint endpoint = SparqlEndpoint.getEndpointDBpediaLiveAKSW();
+ ExtractionDBCache cache = new ExtractionDBCache("cache");
+ Set<String> predicateFilters = new HashSet<String>();
+ predicateFilters.add("http://dbpedia.org/ontology/wikiPageWikiLink");
+ predicateFilters.add("http://dbpedia.org/property/wikiPageUsesTemplate");
+ ModelGenerator modelGen = new ModelGenerator(endpoint, predicateFilters, cache);
+ QueryTreeFactory<String> treeFactory = new QueryTreeFactoryImpl();
+
+ String queryString = "SELECT ?resource WHERE {?resource a ?class." +
+ " FILTER(REGEX(?resource,'http://dbpedia.org/resource'))} LIMIT " + limit;
+ SparqlQuery query = new SparqlQuery(queryString, endpoint);
+ ResultSet rs = query.send();
+
+
+
+ //load the models
+ SortedMap<String, Model> resource2Model = new TreeMap<String, Model>();
+ Model model;
+ String resource;
+ logger.info("Resources(#triple):");
+ while(rs.hasNext()){
+ try {
+ resource = rs.next().get("resource").asResource().getURI();
+ model = modelGen.createModel(resource, Strategy.CHUNKS, recursionDepth);
+ logger.info(resource + "(" + model.size() + ")");
+ resource2Model.put(resource, model);
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+// model = modelGen.createModel("http://dbpedia.org/resource/A_Farewell_to_Arms", Strategy.CHUNKS, recursionDepth);
+// logger.info("http://dbpedia.org/resource/A_Farewell_to_Arms" + "(" + model.size() + ")");
+// resource2Model.put("http://dbpedia.org/resource/A_Farewell_to_Arms", model);
+// model = modelGen.createModel("http://dbpedia.org/resource/Darjeeling", Strategy.CHUNKS, recursionDepth);
+// logger.info("http://dbpedia.org/resource/Darjeeling" + "(" + model.size() + ")");
+// resource2Model.put("http://dbpedia.org/resource/Darjeeling", model);
+
+
+ //create the querytrees
+ SortedMap<String, QueryTree<String>> resource2Tree = new TreeMap<String, QueryTree<String>>();
+ Map<QueryTree<String>, String> tree2Resource = new HashMap<QueryTree<String>, String>(limit);
+ List<QueryTree<String>> trees = new ArrayList<QueryTree<String>>();
+ QueryTree<String> tree;
+ for(Entry<String, Model> entry : resource2Model.entrySet()){
+ try {
+ tree = treeFactory.getQueryTree(entry.getKey(), entry.getValue());
+ trees.add(tree);
+ resource2Tree.put(entry.getKey(), tree);
+ tree2Resource.put(tree, entry.getKey());
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+
+ LGGGenerator<String> lggGen = new LGGGeneratorImpl<String>();
+ QueryTree<String> tree1;
+ QueryTree<String> tree2;
+ QueryTree<String> lgg;
+ for(int i = 0; i < trees.size(); i++){
+ for(int j = i+1; j < trees.size(); j++){
+ try {
+ tree1 = trees.get(i);
+ tree2 = trees.get(j);
+ lgg = lggGen.getLGG(tree1, tree2);
+ logger.info("LGG(" + tree2Resource.get(tree1) + ", " + tree2Resource.get(tree2) + ") needed "
+ + MonitorFactory.getTimeMonitor("LGG").getLastValue() + "ms");
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+// logger.info("Tree 1:\n" + tree1.getStringRepresentation());
+// logger.info("Tree 2:\n" + tree2.getStringRepresentation());
+// logger.info("LGG:\n" + lgg.getStringRepresentation());
+ }
+ }
+ logger.info("Average time to compute LGG: " + MonitorFactory.getTimeMonitor("LGG").getAvg());
+ logger.info("Min time to compute LGG: " + MonitorFactory.getTimeMonitor("LGG").getMin());
+ logger.info("Max time to compute LGG: " + MonitorFactory.getTimeMonitor("LGG").getMax());
+ logger.info("#computed LGGs: " + MonitorFactory.getTimeMonitor("LGG").getHits());
+
+
+ }
+
+}
Added: trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/ModelCreationTest.java
===================================================================
--- trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/ModelCreationTest.java (rev 0)
+++ trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/ModelCreationTest.java 2011-04-05 08:29:44 UTC (rev 2750)
@@ -0,0 +1,306 @@
+package org.dllearner.algorithm.qtl;
+
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import org.apache.log4j.ConsoleAppender;
+import org.apache.log4j.FileAppender;
+import org.apache.log4j.Level;
+import org.apache.log4j.Logger;
+import org.apache.log4j.SimpleLayout;
+import org.dllearner.algorithm.qtl.datastructures.QueryTree;
+import org.dllearner.algorithm.qtl.impl.QueryTreeFactoryImpl;
+import org.dllearner.algorithm.qtl.util.ModelGenerator;
+import org.dllearner.kb.sparql.ExtractionDBCache;
+import org.dllearner.kb.sparql.SparqlEndpoint;
+import org.dllearner.utilities.JamonMonitorLogger;
+import org.junit.Test;
+
+import com.hp.hpl.jena.rdf.model.Model;
+import com.hp.hpl.jena.rdf.model.ModelFactory;
+import com.hp.hpl.jena.sparql.engine.http.QueryEngineHTTP;
+import com.jamonapi.Monitor;
+import com.jamonapi.MonitorFactory;
+
+public class ModelCreationTest {
+
+ private static final int RECURSION_DEPTH = 2;
+ private static final String RESOURCE = "http://dbpedia.org/resource/Dresden";
+
+ private static final Logger logger = Logger.getLogger(ModelCreationTest.class);
+
+ private static final SparqlEndpoint ENDPOINT = SparqlEndpoint.getEndpointDBpediaLiveAKSW();
+
+ @Test
+ public void test1(){
+ try {
+ SimpleLayout layout = new SimpleLayout();
+ ConsoleAppender consoleAppender = new ConsoleAppender(layout);
+ FileAppender fileAppender = new FileAppender(layout,
+ "log/model_test.log", false);
+ logger.removeAllAppenders();
+ logger.addAppender(consoleAppender);
+ logger.addAppender(fileAppender);
+ logger.setLevel(Level.DEBUG);
+ Logger.getLogger(ModelGenerator.class).setLevel(Level.DEBUG);
+ Logger.getLogger(ModelCreationTest.class).setLevel(Level.DEBUG);
+
+
+ URL url = new URL("http://lod.openlinksw.com/sparql/");
+ SparqlEndpoint endpoint = new SparqlEndpoint(url, Collections.singletonList("http://dbpedia.org"), Collections.<String>emptyList());
+ Set<String> predicateFilters = new HashSet<String>();
+ predicateFilters.add("http://dbpedia.org/ontology/wikiPageWikiLink");
+ predicateFilters.add("http://dbpedia.org/property/wikiPageUsesTemplate");
+
+ ModelGenerator modelGen = new ModelGenerator(endpoint, predicateFilters, new ExtractionDBCache("construct-cache"));
+
+// logger.debug("Using chunk strategy.");
+// Model model1 = modelGen.createModel(RESOURCE, ModelGenerator.Strategy.CHUNKS, 2);
+// logger.debug("Got overall " + model1.size() + " triple.");
+//
+// logger.debug("Using incremental strategy.");
+// Model model2 = modelGen.createModel(RESOURCE, ModelGenerator.Strategy.INCREMENTALLY, RECURSION_DEPTH);
+// logger.debug("Got overall " + model2.size() + " triple.");
+
+ logger.debug("Using chunk with optional strategy.");
+ Model model3 = modelGen.createModel(RESOURCE, ModelGenerator.Strategy.CHUNKS, 2);System.out.println(model3.size());
+ logger.debug("Got overall " + model3.size() + " triple.");
+ QueryTreeFactory<String> f = new QueryTreeFactoryImpl();
+ QueryTree<String> t = f.getQueryTree(RESOURCE, model3);
+ System.out.println(t.getStringRepresentation());
+
+// Model diff = ModelFactory.createDefaultModel();
+// if(model1.size() > model2.size()){
+// logger.debug("Chunk strategy returned " + (model1.size() - model2.size()) + " more triple.");
+// diff.add(model1.difference(model2));
+// } else if(model2.size() > model1.size()){
+// logger.debug("Incremental strategy returned " + (model2.size() - model1.size()) + " more triple.");
+// diff.add(model2.difference(model1));
+// } else {
+// logger.debug("Both strategies returned the same number of triple.");
+// }
+//
+// logger.debug("Difference : ");
+// Statement st = null;
+// for(Iterator<Statement> i = diff.listStatements();i.hasNext(); st = i.next()){
+// logger.debug(st);
+// }
+//
+// diff = model3.difference(model1);
+// st = null;
+// System.out.println("Difference between other");
+// for(Iterator<Statement> i = diff.listStatements();i.hasNext(); st = i.next()){
+// System.out.println(st);
+// }
+// assertTrue(model1.size() == model2.size());
+ } catch (MalformedURLException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ } catch (IOException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ @Test
+ public void multiThreadedModelCreationTest(){
+ String resource = "http://dbpedia.org/resource/Munich";
+
+ Model model = ModelFactory.createDefaultModel();
+
+ int proCnt = Runtime.getRuntime().availableProcessors();
+ logger.info("Number of processor: " + proCnt);
+ Future<Model>[] ret = new Future[proCnt];
+ List<String> queries = queries = createSearchQueries("Hamburg", "Vienna", "Stuttgart", "Frankfurt", "Kiel");;//createQueries(resource, proCnt);
+
+ ExecutorService es = Executors.newFixedThreadPool(proCnt);
+ for(int i = 0; i < 5; i++){
+ ret[i] = es.submit(new ModelRetrievalTask(queries.get(i)));
+ }
+
+ for (int i = 0; i < proCnt; i++) {
+ try {
+ model.add(ret[i].get());
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ } catch (ExecutionException e) {
+ e.printStackTrace();
+ }
+ }
+
+ es.shutdown();
+ System.out.println(model.size());
+
+ Model singleThreadedModel = ModelFactory.createDefaultModel();
+ Monitor mon = MonitorFactory.getTimeMonitor("singleThreaded").start();
+ queries = createSearchQueries("Leipzig", "Berlin", "Dresden", "Munich", "Dortmund");
+ for(String query : queries){
+ singleThreadedModel.add(getModel(query));
+ }
+ mon.stop();
+ System.out.println("Single threaded: " + mon.getTotal());
+
+ }
+
+ private class ModelRetrievalTask implements Callable<Model>{
+
+ private String query;
+
+ public ModelRetrievalTask(String query){
+ this.query = query;
+ }
+
+ @Override
+ public Model call() throws Exception {
+ System.out.println(query);
+ Monitor mon = MonitorFactory.getTimeMonitor("query").start();
+ JamonMonitorLogger.getTimeMonitor(ModelCreationTest.class, "time").start();
+ QueryEngineHTTP queryExecution = new QueryEngineHTTP(ENDPOINT.getURL().toString(), query);
+ for (String dgu : ENDPOINT.getDefaultGraphURIs()) {
+ queryExecution.addDefaultGraph(dgu);
+ }
+ for (String ngu : ENDPOINT.getNamedGraphURIs()) {
+ queryExecution.addNamedGraph(ngu);
+ }
+ Model model = queryExecution.execConstruct();
+ mon.stop();
+ System.out.println(mon.getLastValue());
+ return model;
+ }
+
+ }
+
+ private Model getModel(String query){
+ QueryEngineHTTP queryExecution = new QueryEngineHTTP(ENDPOINT.getURL().toString(), query);
+ for (String dgu : ENDPOINT.getDefaultGraphURIs()) {
+ queryExecution.addDefaultGraph(dgu);
+ }
+ for (String ngu : ENDPOINT.getNamedGraphURIs()) {
+ queryExecution.addNamedGraph(ngu);
+ }
+ Model model = queryExecution.execConstruct();
+
+ return model;
+ }
+
+ private List<String> createQueries(String resource, int cnt){
+ List<String> queries = new ArrayList<String>(cnt);
+ for(int i = 0; i < cnt; i++){
+ queries.add(createConstructQuery(resource, 50, i * 50));
+ }
+
+ return queries;
+ }
+
+ private String createConstructQuery(String resource, int limit, int offset){
+
+ StringBuilder sb = new StringBuilder();
+ sb.append("CONSTRUCT {\n");
+ sb.append("<").append(resource).append("> ").append("?p ").append("?o").append(".\n");
+ sb.append("}\n");
+ sb.append("WHERE {\n");
+ sb.append("<").append(resource).append("> ").append("?p ").append("?o").append(".\n");
+
+ sb.append("}\n");
+ sb.append(" LIMIT ").append(limit).append(" OFFSET ").append(offset);
+
+ return sb.toString();
+ }
+
+ private List<String> createSearchQueries(String ... searchTerms){
+ List<String> queries = new ArrayList<String>();
+ for(String term : searchTerms){
+ queries.add(createSearchQuery(term));
+ }
+ return queries;
+ }
+
+ private String createSearchQuery(String searchTerm){
+ StringBuilder sb = new StringBuilder();
+ sb.append("CONSTRUCT");
+ sb.append("{?s ?p ?o.}");
+ sb.append("WHERE");
+ sb.append("{?s ?p ?o.");
+ sb.append("?s rdfs:label ?label.");
+ sb.append("?label bif:contains '").append(searchTerm).append("'.} LIMIT 1000");
+
+// sb.append("SELECT ?s ?label WHERE {?s rdfs:label ?label. ?label bif:contains '").append(searchTerm).append("'.} limit 500");
+ return sb.toString();
+ }
+
+//
+// class ModelProducer implements Runnable{
+//
+// protected BlockingQueue<Model> queue;
+// private int offset;
+//
+// public ModelProducer(BlockingQueue<Model> queue, int offset) {
+// this.queue = queue;
+// this.offset = offset;
+// }
+//
+// @Override
+// public void run() {
+// Model model = getModel(offset);System.out.println(offset + " -> " + model.size());
+// try {
+// queue.put(model);
+// } catch (InterruptedException e) {
+// e.printStackTrace();
+// }
+// }
+//
+// private Model getModel(int offset){
+// Query query = QueryFactory.create(
+// "CONSTRUCT " +
+// "{<http://dbpedia.org/resource/Dresden> ?p1 ?o1. ?o1 ?p2 ?o2.}" +
+// " WHERE " +
+// "{<http://dbpedia.org/resource/Dresden> ?p1 ?o1. ?o1 ?p2 ?o2.}" +
+// "LIMIT 100 OFFSET " + offset);
+//
+// QueryExecution qexec = QueryExecutionFactory.sparqlService(
+// ENDPOINT.getURL().toString(),
+// query,
+// ENDPOINT.getDefaultGraphURIs(),
+// ENDPOINT.getNamedGraphURIs());
+// return qexec.execConstruct();
+// }
+//
+// }
+//
+// class ModelConsumer implements Runnable{
+//
+// protected BlockingQueue<Model> queue;
+// private Model completeModel;
+//
+// public ModelConsumer(BlockingQueue<Model> queue) {
+// this.queue = queue;
+// completeModel = ModelFactory.createDefaultModel();
+// }
+//
+// @Override
+// public void run() {
+// while(true){
+// try {
+// Model m = queue.take();
+// completeModel.add(m);
+// System.out.println(completeModel.size());
+// } catch (InterruptedException e) {
+// e.printStackTrace();
+// }
+// }
+// }
+//
+// }
+
+}
Added: trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/NBRTest.java
===================================================================
--- trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/NBRTest.java (rev 0)
+++ trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/NBRTest.java 2011-04-05 08:29:44 UTC (rev 2750)
@@ -0,0 +1,196 @@
+/**
+ * Copyright (C) 2007-2010, Jens Lehmann
+ *
+ * This file is part of DL-Learner.
+ *
+ * DL-Learner is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * DL-Learner is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package org.dllearner.algorithm.qtl;
+
+import java.util.List;
+
+import org.dllearner.algorithm.qtl.datastructures.QueryTree;
+import org.dllearner.algorithm.qtl.examples.DBpediaExample;
+import org.dllearner.algorithm.qtl.operations.lgg.LGGGenerator;
+import org.dllearner.algorithm.qtl.operations.lgg.LGGGeneratorImpl;
+import org.dllearner.algorithm.qtl.operations.nbr.NBRGenerator;
+import org.dllearner.algorithm.qtl.operations.nbr.NBRGeneratorImpl;
+import org.dllearner.algorithm.qtl.operations.nbr.strategy.BruteForceNBRStrategy;
+import org.dllearner.algorithm.qtl.operations.nbr.strategy.GreedyNBRStrategy;
+import org.dllearner.algorithm.qtl.operations.nbr.strategy.TagNonSubsumingPartsNBRStrategy;
+import org.junit.Test;
+
+/**
+ *
+ * @author Lorenz Bühmann
+ *
+ */
+public class NBRTest {
+
+ @Test
+ public void computeSingleNBRBruteForce(){
+
+ List<QueryTree<String>> posExampleTrees = DBpediaExample.getPosExampleTrees();
+ List<QueryTree<String>> negExampleTrees = DBpediaExample.getNegExampleTrees();
+
+ LGGGenerator<String> lggGenerator = new LGGGeneratorImpl<String>();
+ NBRGenerator<String> nbrGenerator = new NBRGeneratorImpl<String>(new BruteForceNBRStrategy<String>());
+
+ int cnt = 1;
+ for(QueryTree<String> tree : posExampleTrees){
+ System.out.println("POSITIVE EXAMPLE TREE " + cnt);
+ System.out.println(tree.getStringRepresentation());
+ System.out.println("-----------------------------------------------");
+ cnt++;
+ }
+
+ QueryTree<String> lgg = lggGenerator.getLGG(posExampleTrees);
+
+ System.out.println("LGG");
+ System.out.println(lgg.getStringRepresentation());
+
+ System.out.println("-----------------------------------------------");
+
+ cnt = 1;
+ for(QueryTree<String> tree : negExampleTrees){
+ System.out.println("NEGATIVE EXAMPLE TREE " + cnt);
+ System.out.println(tree.getStringRepresentation());
+ System.out.println("-----------------------------------------------");
+ cnt++;
+ }
+
+ QueryTree<String> nbr = nbrGenerator.getNBR(lgg, negExampleTrees);
+
+ System.out.println("NBR");
+ System.out.println(nbr.getStringRepresentation());
+
+ }
+
+ @Test
+ public void computeAllNBRsBruteForce(){
+ List<QueryTree<String>> posExampleTrees = DBpediaExample.getPosExampleTrees();
+ List<QueryTree<String>> negExampleTrees = DBpediaExample.getNegExampleTrees();
+
+ LGGGenerator<String> lggGenerator = new LGGGeneratorImpl<String>();
+ NBRGenerator<String> nbrGenerator = new NBRGeneratorImpl<String>(new BruteForceNBRStrategy<String>());
+
+ int cnt = 1;
+ for(QueryTree<String> tree : posExampleTrees){
+ System.out.println("POSITIVE EXAMPLE TREE " + cnt);
+ System.out.println(tree.getStringRepresentation());
+ System.out.println("-----------------------------------------------");
+ cnt++;
+ }
+
+ QueryTree<String> lgg = lggGenerator.getLGG(posExampleTrees);
+
+ System.out.println("LGG");
+ System.out.println(lgg.getStringRepresentation());
+
+ System.out.println("-----------------------------------------------");
+
+ cnt = 1;
+ for(QueryTree<String> tree : negExampleTrees){
+ System.out.println("NEGATIVE EXAMPLE TREE " + cnt);
+ System.out.println(tree.getStringRepresentation());
+ System.out.println("-----------------------------------------------");
+ cnt++;
+ }
+
+ List<QueryTree<String>> nbrs = nbrGenerator.getNBRs(lgg, negExampleTrees);
+ cnt = 1;
+ for(QueryTree<String> tree : nbrs){
+ System.out.println("NBR " + cnt);
+ System.out.println(tree.getStringRepresentation());
+ System.out.println("-----------------------------------------------");
+ cnt++;
+ }
+ }
+
+ @Test
+ public void computeSingleNBRWithTaggingNonSubsumingParts(){
+ List<QueryTree<String>> posExampleTrees = DBpediaExample.getPosExampleTrees();
+ List<QueryTree<String>> negExampleTrees = DBpediaExample.getNegExampleTrees();
+
+ LGGGenerator<String> lggGenerator = new LGGGeneratorImpl<String>();
+ NBRGenerator<String> nbrGenerator = new NBRGeneratorImpl<String>(new TagNonSubsumingPartsNBRStrategy<String>());
+
+ int cnt = 1;
+ for(QueryTree<String> tree : posExampleTrees){
+ System.out.println("POSITIVE EXAMPLE TREE " + cnt);
+ System.out.println(tree.getStringRepresentation());
+ System.out.println("-----------------------------------------------");
+ cnt++;
+ }
+
+ QueryTree<String> lgg = lggGenerator.getLGG(posExampleTrees);
+
+ System.out.println("LGG");
+ System.out.println(lgg.getStringRepresentation());
+
+ System.out.println("-----------------------------------------------");
+
+ cnt = 1;
+ for(QueryTree<String> tree : negExampleTrees){
+ System.out.println("NEGATIVE EXAMPLE TREE " + cnt);
+ System.out.println(tree.getStringRepresentation());
+ System.out.println("-----------------------------------------------");
+ cnt++;
+ }
+
+ QueryTree<String> nbr = nbrGenerator.getNBR(lgg, negExampleTrees);
+
+ System.out.println("NBR");
+ System.out.println(nbr.getStringRepresentation());
+ }
+
+ @Test
+ public void computeSingleNBRGreedy(){
+ List<QueryTree<String>> posExampleTrees = DBpediaExample.getPosExampleTrees();
+ List<QueryTree<String>> negExampleTrees = DBpediaExample.getNegExampleTrees();
+
+ LGGGenerator<String> lggGenerator = new LGGGeneratorImpl<String>();
+ NBRGenerator<String> nbrGenerator = new NBRGeneratorImpl<String>(new GreedyNBRStrategy<String>());
+
+ int cnt = 1;
+ for(QueryTree<String> tree : posExampleTrees){
+ System.out.println("POSITIVE EXAMPLE TREE " + cnt);
+ System.out.println(tree.getStringRepresentation());
+ System.out.println("-----------------------------------------------");
+ cnt++;
+ }
+
+ QueryTree<String> lgg = lggGenerator.getLGG(posExampleTrees);
+
+ System.out.println("LGG");
+ System.out.println(lgg.getStringRepresentation());
+
+ System.out.println("-----------------------------------------------");
+
+ cnt = 1;
+ for(QueryTree<String> tree : negExampleTrees){
+ System.out.println("NEGATIVE EXAMPLE TREE " + cnt);
+ System.out.println(tree.getStringRepresentation());
+ System.out.println("-----------------------------------------------");
+ cnt++;
+ }
+
+ QueryTree<String> nbr = nbrGenerator.getNBR(lgg, negExampleTrees);
+
+ System.out.println("NBR");
+ System.out.println(nbr.getStringRepresentation());
+ }
+
+}
Added: trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/TreeSubsumptionTest.java
===================================================================
--- trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/TreeSubsumptionTest.java (rev 0)
+++ trunk/components-ext/src/test/java/org/dllearner/algorithm/qtl/TreeSubsumptionTest.java 2011-04-05 08:29:44 UTC (rev 2750)
@@ -0,0 +1,67 @@
+/**
+ * Copyright (C) 2007-2010, Jens Lehmann
+ *
+ * This file is part of DL-Learner.
+ *
+ * DL-Learner is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * DL-Learner is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+package org.dllearner.algorithm.qtl;
+
+import org.dllearner.algorithm.qtl.datastructures.impl.QueryTreeImpl;
+import org.junit.Assert;
+import org.junit.Test;
+
+
+
+/**
+ *
+ * @author Lorenz Bühmann
+ *
+ */
+public class TreeSubsumptionTest{
+
+ @Test
+ public void test1(){
+ QueryTreeImpl<String> tree1 = new QueryTreeImpl<String>("A");
+ QueryTreeImpl<String> tree2 = new QueryTreeImpl<String>("?");
+ Assert.assertTrue(tree1.isSubsumedBy(tree2));
+ }
+
+ @Test
+ public void test2(){
+ QueryTreeImpl<String> tree1 = new QueryTreeImpl<String>("A");
+ tree1.addChild(new QueryTreeImpl<String>("B"), "r");
+
+ QueryTreeImpl<String> tree2 = new QueryTreeImpl<String>("?");
+ QueryTreeImpl<String> child = new QueryTreeImpl<String>("A");
+ child.addChild(new QueryTreeImpl<String>("B"), "r");
+ tree2.addChild(child, "r");
+ Assert.assertFalse(tree1.isSubsumedBy(tree2));
+ }
+
+ @Test
+ public void test3(){
+ QueryTreeImpl<String> tree1 = new QueryTreeImpl<String>("?");
+ tree1.addChild(new QueryTreeImpl<String>("B"), "r");
+ tree1.addChild(new QueryTreeImpl<String>("A"), "s");
+
+ QueryTreeImpl<String> tree2 = new QueryTreeImpl<String>("?");
+ tree2.addChild(new QueryTreeImpl<String>("A"), "r");
+ tree2.addChild(new QueryTreeImpl<String>("B"), "r");
+ tree2.addChild(new QueryTreeImpl<String>("C"), "s");
+ Assert.assertFalse(tree2.isSubsumedBy(tree1));
+ }
+
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
