Thread: [DL-Learner SVN] SF.net SVN: dl-learner:[2747] trunk/scripts/src/main/java/org/dllearner/ scripts/i

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 2747
          http://dl-learner.svn.sourceforge.net/dl-learner/?rev=2747&view=rev
Author:   kurzum
Date:     2011-04-04 14:17:14 +0000 (Mon, 04 Apr 2011)

Log Message:
-----------
script for relearning dbpedia ontology 

Modified Paths:
--------------
    trunk/scripts/src/main/java/org/dllearner/scripts/improveWikipedia/DBpediaClassLearnerCELOE.java
    trunk/scripts/src/main/java/org/dllearner/scripts/improveWikipedia/InstanceFinderSPARQL.java

Modified: trunk/scripts/src/main/java/org/dllearner/scripts/improveWikipedia/DBpediaClassLearnerCELOE.java
===================================================================

--- trunk/scripts/src/main/java/org/dllearner/scripts/improveWikipedia/DBpediaClassLearnerCELOE.java	2011-04-04 07:21:31 UTC (rev 2746)
+++ trunk/scripts/src/main/java/org/dllearner/scripts/improveWikipedia/DBpediaClassLearnerCELOE.java	2011-04-04 14:17:14 UTC (rev 2747)
@@ -2,7 +2,7 @@
  * Copyright (C) 2007-2011, Jens Lehmann
  *
  * This file is part of DL-Learner.
- * 
+ *
  * DL-Learner is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 3 of the License, or
@@ -19,96 +19,147 @@
  */
 package org.dllearner.scripts.improveWikipedia;
 
-import java.io.File;
-import java.io.IOException;
-import java.util.Set;
-import java.util.SortedSet;
-
+import org.aksw.commons.sparql.core.ResultSetRenderer;
+import org.aksw.commons.sparql.core.SparqlEndpoint;
+import org.aksw.commons.sparql.core.SparqlTemplate;
+import org.aksw.commons.sparql.core.decorator.CachingSparqlEndpoint;
+import org.aksw.commons.sparql.core.impl.HttpSparqlEndpoint;
+import org.apache.velocity.VelocityContext;
+import org.apache.velocity.app.Velocity;
 import org.dllearner.algorithms.celoe.CELOE;
 import org.dllearner.core.ComponentManager;
 import org.dllearner.core.LearningProblemUnsupportedException;
 import org.dllearner.core.OntologyFormat;
 import org.dllearner.core.ReasonerComponent;
 import org.dllearner.core.configurators.CELOEConfigurator;
-import org.dllearner.core.owl.Description;
-import org.dllearner.core.owl.EquivalentClassesAxiom;
-import org.dllearner.core.owl.Individual;
-import org.dllearner.core.owl.KB;
-import org.dllearner.core.owl.NamedClass;
+import org.dllearner.core.owl.*;
 import org.dllearner.gui.Config;
 import org.dllearner.gui.ConfigSave;
 import org.dllearner.kb.sparql.SparqlKnowledgeSource;
 import org.dllearner.learningproblems.PosNegLPStandard;
 import org.dllearner.reasoning.FastInstanceChecker;
+import org.dllearner.utilities.Helper;
 import org.dllearner.utilities.datastructures.Datastructures;
 import org.dllearner.utilities.datastructures.SortedSetTuple;
 
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.SortedSet;
+
 /**
  * A script, which learns definitions / super classes of classes in the DBpedia ontology.
- * 
+ *
  * @author Jens Lehmann
- *
  */
 public class DBpediaClassLearnerCELOE {
-    //SparqlEndpoint  se ;
+    SparqlEndpoint sparqlEndpoint = new CachingSparqlEndpoint(new HttpSparqlEndpoint("http://dbpedia.org/sparql", "http://dbpedia.org"), "cache/");
 
-	public DBpediaClassLearnerCELOE() {
-		// OPTIONAL: if you want to do some case distinctions in the learnClass method, you could add
-		// parameters to the constructure e.g. YAGO_ 
-	}
-	
-	public KB learnAllClasses(Set<String> classesToLearn) throws LearningProblemUnsupportedException, IOException {
-		KB kb = new KB();
-		for(String classToLearn : classesToLearn) {
-			kb.addAxiom(new EquivalentClassesAxiom(new NamedClass(classToLearn), learnClass(classToLearn)));
-		}
-		return kb;
-	}
-	
-	public Description learnClass(String classToLearn) throws LearningProblemUnsupportedException, IOException {
-		
-		// TODO: code for getting postive and negative examples for class to learn
-		SortedSet<Individual> posExamples = null;
-		SortedSet<Individual> negExamples = null;
-		SortedSetTuple<Individual> examples = new SortedSetTuple<Individual>(posExamples, negExamples);
-		
-		ComponentManager cm = ComponentManager.getInstance();
-		
-		SparqlKnowledgeSource ks = cm.knowledgeSource(SparqlKnowledgeSource.class);
-		ks.getConfigurator().setInstances(Datastructures.individualSetToStringSet(examples.getCompleteSet()));
-		ks.getConfigurator().setPredefinedEndpoint("DBPEDIA"); // TODO: probably the official endpoint is too slow?
-		
-		ReasonerComponent rc = cm.reasoner(FastInstanceChecker.class, ks);
-		
-		PosNegLPStandard lp = cm.learningProblem(PosNegLPStandard.class, rc);
-		lp.getConfigurator().setAccuracyMethod("fMeasure");
-		lp.getConfigurator().setUseApproximations(false);
-		
-		CELOE la = cm.learningAlgorithm(CELOE.class, lp, rc);
-		CELOEConfigurator cc = la.getConfigurator();
-		cc.setMaxExecutionTimeInSeconds(100);
-		cc.setNoisePercentage(20);
-		// TODO: set more options as needed
-		
-		// to write the above configuration in a conf file (optional)
-		Config cf = new Config(cm, ks, rc, lp, la);
-		new ConfigSave(cf).saveFile(new File("/dev/null"));
-		
-		la.start();
-		
-		return la.getCurrentlyBestDescription();
-	}
-	
-	public static void main(String args[]) throws LearningProblemUnsupportedException, IOException {
-		DBpediaClassLearnerCELOE dcl = new DBpediaClassLearnerCELOE();
-		Set<String> classesToLearn = null;
-		KB kb = dcl.learnAllClasses(classesToLearn);
-		kb.export(new File("/dev/null"), OntologyFormat.RDF_XML); // TODO: pick appropriate place to save ontology
-	}
+    public DBpediaClassLearnerCELOE() {
+        // OPTIONAL: if you want to do some case distinctions in the learnClass method, you could add
+        // parameters to the constructure e.g. YAGO_
+    }
 
+    public KB learnAllClasses(Set<String> classesToLearn) throws LearningProblemUnsupportedException, IOException {
+        KB kb = new KB();
+        for (String classToLearn : classesToLearn) {
+            Description d = learnClass(classToLearn);
+            if (d == null) {
+                continue;
+            }
+            kb.addAxiom(new EquivalentClassesAxiom(new NamedClass(classToLearn), d));
+        }
+        return kb;
+    }
 
-    public Set<String> getInstances(){
-        return null;
+    public Description learnClass(String classToLearn) throws LearningProblemUnsupportedException, IOException {
+        Set<String> posEx = getPosEx(classToLearn);
+        if (posEx.isEmpty()) {
+            return null;
+        }
+        Set<String> classes = new HashSet<String>();
+
+        for (String pos : posEx) {
+            SparqlTemplate st = new SparqlTemplate(0);
+            st.addFilter(sparqlEndpoint.like("classes", new HashSet<String>(Arrays.asList(new String[]{"http://dbpedia.org/ontology/"}))));
+            VelocityContext vc = new VelocityContext();
+            vc.put("instance", pos );
+            String query = st.getQuery("sparqltemplates/directClassesOfInstance.vm", vc);
+            classes.addAll(ResultSetRenderer.asStringSet(sparqlEndpoint.executeSelect(query)));
+            classes.remove(classToLearn);
+        }
+        System.out.println(classes.size());
+        System.exit(0);
+
+        Set<String> negEx = new HashSet<String>();
+        for (String oneClass : classes) {
+           /* st = new SparqlTemplate(0);
+            st.addFilter(sparqlEndpoint.like("classes", new HashSet<String>(Arrays.asList(new String[]{"http://dbpedia.org/ontology/"}))));
+            query = st.getQuery("sparqltemplates/classesOfInstance.vm", new VelocityContext());
+            classes.addAll(ResultSetRenderer.asStringSet(sparqlEndpoint.executeSelect(query)));
+            classes.remove(classToLearn);*/
+        }
+        //System.out.println(posEx);
+        System.exit(0);
+        //Set<String> negEx = InstanceFinderSPARQL.findInstancesWithSimilarClasses(posEx, -1, sparqlEndpoint);
+        SortedSet<Individual> posExamples = Helper.getIndividualSet(posEx);
+        SortedSet<Individual> negExamples = Helper.getIndividualSet(negEx);
+        SortedSetTuple<Individual> examples = new SortedSetTuple<Individual>(posExamples, negExamples);
+        System.out.println(posEx.size());
+        System.out.println(negEx.size());
+        System.exit(0);
+        ComponentManager cm = ComponentManager.getInstance();
+
+        SparqlKnowledgeSource ks = cm.knowledgeSource(SparqlKnowledgeSource.class);
+        ks.getConfigurator().setInstances(Datastructures.individualSetToStringSet(examples.getCompleteSet()));
+        ks.getConfigurator().setPredefinedEndpoint("DBPEDIA"); // TODO: probably the official endpoint is too slow?
+
+        ReasonerComponent rc = cm.reasoner(FastInstanceChecker.class, ks);
+
+        PosNegLPStandard lp = cm.learningProblem(PosNegLPStandard.class, rc);
+        lp.getConfigurator().setAccuracyMethod("fMeasure");
+        lp.getConfigurator().setUseApproximations(false);
+
+        CELOE la = cm.learningAlgorithm(CELOE.class, lp, rc);
+        CELOEConfigurator cc = la.getConfigurator();
+        cc.setMaxExecutionTimeInSeconds(100);
+        cc.setNoisePercentage(20);
+        // TODO: set more options as needed
+
+        // to write the above configuration in a conf file (optional)
+        Config cf = new Config(cm, ks, rc, lp, la);
+        new ConfigSave(cf).saveFile(new File("/dev/null"));
+
+        la.start();
+
+        return la.getCurrentlyBestDescription();
     }
-	
+
+    public static void main(String args[]) throws LearningProblemUnsupportedException, IOException {
+
+        DBpediaClassLearnerCELOE dcl = new DBpediaClassLearnerCELOE();
+        SparqlTemplate st = new SparqlTemplate(0);
+        st.addFilter(dcl.sparqlEndpoint.like("classes", new HashSet<String>(Arrays.asList(new String[]{"http://dbpedia.org/ontology/"}))));
+
+        String query = st.getQuery("sparqltemplates/allClasses.vm", new VelocityContext());
+        //System.out.println(query);
+        Set<String> classesToLearn = ResultSetRenderer.asStringSet(dcl.sparqlEndpoint.executeSelect(query));
+        //System.out.println(classesToLearn);
+
+        KB kb = dcl.learnAllClasses(classesToLearn);
+        System.exit(0);
+        kb.export(new File("/dev/null"), OntologyFormat.RDF_XML); // TODO: pick appropriate place to save ontology
+    }
+
+
+    public Set<String> getPosEx(String clazz) {
+        VelocityContext vc = new VelocityContext();
+        vc.put("class", clazz);
+        vc.put("limit", 0);
+        String query = SparqlTemplate.instancesOfClass(vc);
+        return ResultSetRenderer.asStringSet(sparqlEndpoint.executeSelect(query));
+    }
+
 }

Modified: trunk/scripts/src/main/java/org/dllearner/scripts/improveWikipedia/InstanceFinderSPARQL.java
===================================================================
--- trunk/scripts/src/main/java/org/dllearner/scripts/improveWikipedia/InstanceFinderSPARQL.java	2011-04-04 07:21:31 UTC (rev 2746)
+++ trunk/scripts/src/main/java/org/dllearner/scripts/improveWikipedia/InstanceFinderSPARQL.java	2011-04-04 14:17:14 UTC (rev 2747)
@@ -22,78 +22,148 @@
 import com.hp.hpl.jena.query.ResultSet;
 import com.hp.hpl.jena.vocabulary.OWL;
 import com.hp.hpl.jena.vocabulary.RDF;
+import org.aksw.commons.sparql.core.ResultSetRenderer;
 import org.aksw.commons.sparql.core.SparqlEndpoint;
+import org.aksw.commons.sparql.core.SparqlTemplate;
 import org.apache.log4j.Logger;
+import org.apache.velocity.VelocityContext;
+import org.dllearner.algorithm.tbsl.learning.SPARQLTemplateBasedLearner;
 import org.dllearner.kb.sparql.SPARQLTasks;
 import org.dllearner.utilities.datastructures.SetManipulation;
-import org.dllearner.utilities.owl.OWLVocabulary;
 
-import java.util.Iterator;
-import java.util.Set;
-import java.util.SortedSet;
-import java.util.TreeSet;
+import java.util.*;
 
 public class InstanceFinderSPARQL {
 
     // LOGGER: ComponentManager
     private static Logger logger = Logger.getLogger(InstanceFinderSPARQL.class);
 
+    /**
+     * query is SELECT ?subject { ?subject rdf:type owl:Thing  } LIMIT 100
+     *
+     * @param blacklist      instances removed from the returned set
+     * @param sparqlEndpoint
+     * @param limit          if <= 0, 100 will be used
+     * @return a set of uris
+     */
+    public static Set<String> arbitraryInstances(Set<String> blacklist, SparqlEndpoint sparqlEndpoint, int limit) {
+        String query = "SELECT ?subject { ?subject <" + RDF.type + "> <" + OWL.Thing + "> } " + ((limit > 0) ? "LIMIT " + limit : " LIMIT 100");
+        ResultSet r = sparqlEndpoint.executeSelect(query);
+        Set<String> s = ResultSetRenderer.asStringSet(r);
+        s.removeAll(blacklist);
+        logger.debug("retrieving " + s.size() + " random instances ");
+        return s;
+    }
 
-    public static void randomInstances(Set<String> blacklist, SparqlEndpoint se) {
-        logger.debug("retrieving random instances ");
-        String query = "SELECT ?subject { ?subject <" + RDF.type + "> <" + OWL.Thing + "> } ";
 
-        //ResultSet r = se.executeSelect(query);
+    /**
+     * TODO refactor
+     * makes neg ex from related instances, that take part in a role R(pos,neg)
+     * filters all objects, that don't use the given namespace
+     *
+     * @param instances
+     */
+    public static void relatedInstances(Set<String> instances, Set<String> blacklist, Set<String> allowedProperties, SparqlEndpoint sparqlEndpoint) {
+        /*public void makeNegativeExamplesFromRelatedInstances(SortedSet<String> instances,
+                                                            String objectNamespace) {
+           logger.debug("making examples from related instances");
+           for (String oneInstance : instances) {
+               //makeNegativeExamplesFromRelatedInstances(oneInstance, objectNamespace);
+           }
+           logger.debug("|-negExample size from related: " + fromRelated.size());
+       } */
+        /*String query = "SELECT * { " + "<" + oneInstance + "> " + "?p ?object.}"
+               + "FILTER (REGEX(str(?object), '" + objectnamespace + "')).\n" + "}";
+       // SortedSet<String> result = new TreeSet<String>();
 
+       String SPARQLquery = "SELECT * WHERE { \n" + "<" + oneInstance + "> " + "?p ?object. \n"
+               + "FILTER (REGEX(str(?object), '" + objectnamespace + "')).\n" + "}";
 
-        //fromRandom = sparqltasks.queryAsSet(sparqlQueryString, variable);
-        //fromRandom.removeAll(fullPositiveSet);
-        //logger.debug("|-negExample size from random: " + fromRandom.size());
-
+       fromRelated.addAll(sparqltasks.queryAsSet(SPARQLquery, "object"));
+       fromRelated.removeAll(fullPositiveSet);
+        */
     }
-    private SPARQLTasks sparqltasks;
 
-    private SortedSet<String> filterClasses;
 
-    private SortedSet<String> fullPositiveSet;
+    /**
+     * TODO document
+     * @param instances this will serve as a blacklist also
+     */
+    public static Set<String> findInstancesWithSimilarClasses(Set<String> instances,
+                                                              int limit, SparqlEndpoint sparqlEndpoint) {
+        Set<String> classes = new HashSet<String>();
+        Set<String> ret = new HashSet<String>();
+        for (String instance : instances) {
+            try {
+               SparqlTemplate st = new SparqlTemplate(0);
+                //st.addFilter(sparqlEndpoint.like());
+                VelocityContext vc = new VelocityContext();
+                vc.put("instance", instance);
+                vc.put("limit", limit);
+                String query = SparqlTemplate.classesOfInstance(vc);
+                classes.addAll(ResultSetRenderer.asStringSet(sparqlEndpoint.executeSelect(query)));
+            } catch (Exception e) {
+                logger.warn("ignoring SPARQLQuery failure geClasses for " + instance);
+            }
 
-    private SortedSet<String> fromRelated = new TreeSet<String>();
-    private SortedSet<String> fromNearbyClasses = new TreeSet<String>();
-    private SortedSet<String> fromSuperclasses = new TreeSet<String>();
-    private SortedSet<String> fromParallelClasses = new TreeSet<String>();
-    private SortedSet<String> fromRandom = new TreeSet<String>();
-    private SortedSet<String> fromDomain = new TreeSet<String>();
-    private SortedSet<String> fromRange = new TreeSet<String>();
-    static int poslimit = 10;
-    static int neglimit = 20;
+        }
+        System.out.println(classes);
+        System.exit(0);
 
+        logger.debug("retrieved " + classes.size() + " classes");
 
-    /**
-     * takes as input a full positive set to make sure no negatives are added as positives
-     *
-     * @param fullPositiveSet
-     * @param st
-     */
-    public InstanceFinderSPARQL(
-            SortedSet<String> fullPositiveSet,
-            SPARQLTasks st, SortedSet<String> filterClasses) {
-        super();
-        this.fullPositiveSet = new TreeSet<String>();
-        this.fullPositiveSet.addAll(fullPositiveSet);
-        this.sparqltasks = st;
-        this.filterClasses = filterClasses;
-    }
 
+        for (String oneClass : classes) {
+            logger.debug(oneClass);
+            try {
+                VelocityContext vc = new VelocityContext();
+                vc.put("class", oneClass);
+                vc.put("limit", limit);
+                String query = SparqlTemplate.classesOfInstance(vc);
+                ret.addAll(ResultSetRenderer.asStringSet(sparqlEndpoint.executeSelect(query)));
+            } catch (Exception e) {
+                logger.warn("ignoring SPARQLQuery failure classesOfInstance for " + oneClass);
+            }
+        }
 
-    /**
-     * see <code>  getNegativeExamples(int neglimit, boolean stable )</code>
-     *
-     * @param neglimit
-     */
-    public SortedSet<String> getNegativeExamples(int neglimit) {
-        return getNegativeExamples(neglimit, false);
+        ret.removeAll(instances);
+        return ret;
+
+        // superClasses.add(concept.replace("\"", ""));
+        // logger.debug("before"+superClasses);
+        // superClasses = dbpediaGetSuperClasses( superClasses, 4);
+        // logger.debug("getting negExamples from "+superClasses.size()+"
+        // superclasses");
+
+        /*for (String oneClass : classes) {
+            logger.debug(oneClass);
+            // rsc = new
+            // JenaResultSetConvenience(queryConcept("\""+oneClass+"\"",limit));
+            try {
+                this.fromParallelClasses.addAll(sparqltasks.retrieveInstancesForClassDescription("\"" + oneClass
+                        + "\"", sparqlResultLimit));
+            } catch (Exception e) {
+                logger.warn("ignoring SPARQLQuery failure, see log/sparql.txt");
+            }
+        }
+
+        for (String instance : positiveSet) {
+            try {
+                classes.addAll(sparqltasks.getClassesForInstance(instance, sparqlResultLimit));
+
+            }
+            logger.debug("getting negExamples from " + classes.size() + " parallel classes");
+
+
+            fromParallelClasses.removeAll(fullPositiveSet);
+            logger.debug("|-neg Example size from parallelclass: " + fromParallelClasses.size());
+           */
     }
 
+
+
+
+
     /**
      * aggregates all collected neg examples
      * CAVE: it is necessary to call one of the make functions before calling this
@@ -102,7 +172,10 @@
      * @param neglimit size of negative Example set, 0 means all, which can be quite large several thousands
      * @param stable   decides whether neg Examples are randomly picked, default false, faster for developing, since the cache can be used
      */
-    public SortedSet<String> getNegativeExamples(int neglimit, boolean stable) {
+    /*public SortedSet<String> getNegativeExamples
+    (
+            int neglimit,
+            boolean stable) {
         SortedSet<String> negatives = new TreeSet<String>();
         negatives.addAll(fromNearbyClasses);
         negatives.addAll(fromParallelClasses);
@@ -124,60 +197,22 @@
         }
         logger.debug("neg Example size after shrinking: " + negatives.size());
         return negatives;
-    }
+    }  */
 
 
-    public void makeNegativeExamplesFromRandomInstances() {
-        logger.debug("making random examples ");
-        String variable = "subject";
-        String sparqlQueryString = "SELECT ?" + variable + " WHERE {" +
-                "?" + variable + " <" + OWLVocabulary.RDF_TYPE + ">" + " ?o" +
-                "}";
-
-        fromRandom = sparqltasks.queryAsSet(sparqlQueryString, variable);
-        fromRandom.removeAll(fullPositiveSet);
-        logger.debug("|-negExample size from random: " + fromRandom.size());
-    }
-
-    /**
-     * makes neg ex from related instances, that take part in a role R(pos,neg)
-     * filters all objects, that don't use the given namespace
-     *
-     * @param instances
-     * @param objectNamespace
-     */
-    public void makeNegativeExamplesFromRelatedInstances(SortedSet<String> instances,
-                                                         String objectNamespace) {
-        logger.debug("making examples from related instances");
-        for (String oneInstance : instances) {
-            makeNegativeExamplesFromRelatedInstances(oneInstance, objectNamespace);
-        }
-        logger.debug("|-negExample size from related: " + fromRelated.size());
-    }
-
-    private void makeNegativeExamplesFromRelatedInstances(String oneInstance, String objectnamespace) {
-        // SortedSet<String> result = new TreeSet<String>();
-
-        String SPARQLquery = "SELECT * WHERE { \n" + "<" + oneInstance + "> " + "?p ?object. \n"
-                + "FILTER (REGEX(str(?object), '" + objectnamespace + "')).\n" + "}";
-
-        fromRelated.addAll(sparqltasks.queryAsSet(SPARQLquery, "object"));
-        fromRelated.removeAll(fullPositiveSet);
-
-    }
-
     // keep a while may still be needed
     /*public void dbpediaMakeNegativeExamplesFromRelatedInstances(String subject) {
-         // SortedSet<String> result = new TreeSet<String>();
+        // SortedSet<String> result = new TreeSet<String>();
 
-         String SPARQLquery = "SELECT * WHERE { \n" + "<" + subject + "> " + "?p ?o. \n"
-                 + "FILTER (REGEX(str(?o), 'http://dbpedia.org/resource/')).\n"
-                 + "FILTER (!REGEX(str(?p), 'http://www.w3.org/2004/02/skos'))\n" + "}";
+        String SPARQLquery = "SELECT * WHERE { \n" + "<" + subject + "> " + "?p ?o. \n"
+                + "FILTER (REGEX(str(?o), 'http://dbpedia.org/resource/')).\n"
+                + "FILTER (!REGEX(str(?p), 'http://www.w3.org/2004/02/skos'))\n" + "}";
 
-         this.fromRelated.addAll(sparqltasks.queryAsSet(SPARQLquery, "o"));
+        this.fromRelated.addAll(sparqltasks.queryAsSet(SPARQLquery, "o"));
 
-     }*/
+    }*/
 
+   /*
     public void makeNegativeExamplesFromNearbyClasses(SortedSet<String> positiveSet, int sparqlResultLimit) {
         SortedSet<String> classes = new TreeSet<String>();
         Iterator<String> instanceIter = positiveSet.iterator();
@@ -220,54 +255,8 @@
         this.fromNearbyClasses.removeAll(fullPositiveSet);
     }
 
-    /**
-     * makes negEx from classes, the posEx belong to.
-     * Gets all Classes from PosEx, gets Instances from these Classes, returns all
-     *
-     * @param positiveSet
-     * @param sparqlResultLimit
      */
-    public void makeNegativeExamplesFromParallelClasses(SortedSet<String> positiveSet, int sparqlResultLimit) {
-        makeNegativeExamplesFromClassesOfInstances(positiveSet, sparqlResultLimit);
-    }
 
-    private void makeNegativeExamplesFromClassesOfInstances(SortedSet<String> positiveSet,
-                                                            int sparqlResultLimit) {
-        logger.debug("making neg Examples from parallel classes");
-        SortedSet<String> classes = new TreeSet<String>();
-        // superClasses.add(concept.replace("\"", ""));
-        // logger.debug("before"+superClasses);
-        // superClasses = dbpediaGetSuperClasses( superClasses, 4);
-        // logger.debug("getting negExamples from "+superClasses.size()+"
-        // superclasses");
-
-        for (String instance : positiveSet) {
-            try {
-                classes.addAll(sparqltasks.getClassesForInstance(instance, sparqlResultLimit));
-            } catch (Exception e) {
-                e.printStackTrace();
-                logger.warn("ignoring SPARQLQuery failure, see log/sparql.txt");
-            }
-        }
-        logger.debug("getting negExamples from " + classes.size() + " parallel classes");
-        for (String oneClass : classes) {
-            logger.debug(oneClass);
-            // rsc = new
-            // JenaResultSetConvenience(queryConcept("\""+oneClass+"\"",limit));
-            try {
-                this.fromParallelClasses.addAll(sparqltasks.retrieveInstancesForClassDescription("\"" + oneClass
-                        + "\"", sparqlResultLimit));
-            } catch (Exception e) {
-                logger.warn("ignoring SPARQLQuery failure, see log/sparql.txt");
-            }
-        }
-
-        fromParallelClasses.removeAll(fullPositiveSet);
-        logger.debug("|-neg Example size from parallelclass: " + fromParallelClasses.size());
-
-    }
-
-
     /**
      * it gets the first class of an arbitrary  instance and queries the superclasses of it,
      * could be more elaborate.
@@ -276,7 +265,7 @@
      * @param positiveSet
      * @param sparqlResultSetLimit
      */
-    public void makeNegativeExamplesFromSuperClassesOfInstances(SortedSet<String> positiveSet,
+   /* public void makeNegativeExamplesFromSuperClassesOfInstances(SortedSet<String> positiveSet,
                                                                 int sparqlResultSetLimit) {
         SortedSet<String> classes = new TreeSet<String>();
         Iterator<String> instanceIter = positiveSet.iterator();
@@ -291,13 +280,14 @@
     public void makeNegativeExamplesFromSuperClasses(String concept, int sparqlResultSetLimit) {
         makeNegativeExamplesFromSuperClasses(concept, sparqlResultSetLimit, 2);
     }
-
+    */
     /**
      * if pos ex derive from one class, then neg ex are taken from a superclass
      *
      * @param concept
      * @param sparqlResultSetLimit
      */
+    /*
     public void makeNegativeExamplesFromSuperClasses(String concept, int sparqlResultSetLimit, int depth) {
 
         concept = concept.replaceAll("\"", "");
@@ -331,4 +321,5 @@
         fromRange.removeAll(fullPositiveSet);
         logger.debug("|-neg Example size from Range: " + fromRange.size());
     }
+    */
 }


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




Thread: [DL-Learner SVN] SF.net SVN: dl-learner:[2747] trunk/scripts/src/main/java/org/dllearner/ scripts/i

dl-learner-svn