[DL-Learner SVN] SF.net SVN: dl-learner:[3950] trunk

[<lor...@us...>]

Revision: 3950
          http://sourceforge.net/p/dl-learner/code/3950
Author:   lorenz_b
Date:     2013-05-05 14:24:32 +0000 (Sun, 05 May 2013)
Log Message:
-----------
Added script to evaluate patterns.

Modified Paths:
--------------
    trunk/components-core/src/main/java/org/dllearner/core/EvaluatedAxiom.java
    trunk/components-core/src/main/java/org/dllearner/reasoning/SPARQLReasoner.java
    trunk/components-core/src/main/java/org/dllearner/utilities/owl/OWLClassExpressionToSPARQLConverter.java

Added Paths:
-----------
    trunk/scripts/src/main/java/org/dllearner/scripts/pattern/
    trunk/scripts/src/main/java/org/dllearner/scripts/pattern/OWLAxiomPatternDetectionEvaluation.java
    trunk/scripts/src/main/java/org/dllearner/scripts/pattern/OWLAxiomPatternUsageEvaluation.java

Removed Paths:
-------------
    trunk/scripts/src/main/java/org/dllearner/scripts/OWLAxiomPatternDetectionEvaluation.java

Modified: trunk/components-core/src/main/java/org/dllearner/core/EvaluatedAxiom.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/core/EvaluatedAxiom.java	2013-05-04 11:27:51 UTC (rev 3949)
+++ trunk/components-core/src/main/java/org/dllearner/core/EvaluatedAxiom.java	2013-05-05 14:24:32 UTC (rev 3950)
@@ -26,11 +26,14 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
 
 import org.apache.commons.codec.digest.DigestUtils;
 import org.dllearner.core.owl.Axiom;
 import org.dllearner.utilities.EnrichmentVocabulary;
 import org.dllearner.utilities.PrefixCCMap;
+import org.dllearner.utilities.owl.AxiomComparator;
 import org.dllearner.utilities.owl.OWLAPIConverter;
 import org.semanticweb.owlapi.model.IRI;
 import org.semanticweb.owlapi.model.OWLAnnotation;
@@ -44,9 +47,10 @@
 import uk.ac.manchester.cs.owl.owlapi.mansyntaxrenderer.ManchesterOWLSyntaxObjectRenderer;
 import uk.ac.manchester.cs.owl.owlapi.mansyntaxrenderer.ManchesterOWLSyntaxPrefixNameShortFormProvider;
 
-public class EvaluatedAxiom {
+public class EvaluatedAxiom implements Comparable<EvaluatedAxiom>{
 	
 	private static DecimalFormat df = new DecimalFormat("##0.0");
+	private AxiomComparator axiomComparator = new AxiomComparator();
 	
 	private Axiom axiom;
 	private Score score;
@@ -136,5 +140,38 @@
 		return str;
 	}
 	
+	public static List<EvaluatedAxiom> getBestEvaluatedAxioms(Set<EvaluatedAxiom> evaluatedAxioms, int nrOfAxioms) {
+		return getBestEvaluatedAxioms(evaluatedAxioms, nrOfAxioms, 0.0);
+	}
+	
+	public static List<EvaluatedAxiom> getBestEvaluatedAxioms(Set<EvaluatedAxiom> evaluatedAxioms, double accuracyThreshold) {
+		return getBestEvaluatedAxioms(evaluatedAxioms, Integer.MAX_VALUE, accuracyThreshold);
+	}
 
+	public static List<EvaluatedAxiom> getBestEvaluatedAxioms(Set<EvaluatedAxiom> evaluatedAxioms, int nrOfAxioms,
+			double accuracyThreshold) {
+		List<EvaluatedAxiom> returnList = new ArrayList<EvaluatedAxiom>();
+		
+		//get the currently best evaluated axioms
+		Set<EvaluatedAxiom> orderedEvaluatedAxioms = new TreeSet<EvaluatedAxiom>(evaluatedAxioms);
+		
+		for(EvaluatedAxiom evAx : orderedEvaluatedAxioms){
+			if(evAx.getScore().getAccuracy() >= accuracyThreshold && returnList.size() < nrOfAxioms){
+				returnList.add(evAx);
+			}
+		}
+		
+		return returnList;
+	}
+	
+	@Override
+	public int compareTo(EvaluatedAxiom other) {
+		int ret = Double.compare(score.getAccuracy(), other.getScore().getAccuracy());
+		if(ret == 0){
+			ret = axiomComparator.compare(axiom, other.getAxiom());
+		}
+		return ret;
+	}
+	
+
 }

Modified: trunk/components-core/src/main/java/org/dllearner/reasoning/SPARQLReasoner.java
===================================================================
--- trunk/components-core/src/main/java/org/dllearner/reasoning/SPARQLReasoner.java	2013-05-04 11:27:51 UTC (rev 3949)
+++ trunk/components-core/src/main/java/org/dllearner/reasoning/SPARQLReasoner.java	2013-05-05 14:24:32 UTC (rev 3950)
@@ -450,8 +450,12 @@
 	}
 	
 	public Set<NamedClass> getTypes() {
+		return getTypes((String)null);
+	}
+	
+	public Set<NamedClass> getTypes(String namespace) {
 		Set<NamedClass> types = new TreeSet<NamedClass>();
-		String query = String.format("SELECT DISTINCT ?class WHERE {[] a ?class.}");
+		String query = String.format("SELECT DISTINCT ?class WHERE {[] a ?class." + (namespace != null ? ("FILTER(REGEX(?class,'^" + namespace + "'))") : "") + "}");
 		ResultSet rs = executeSelectQuery(query);
 		QuerySolution qs;
 		while(rs.hasNext()){

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-05-04 11:27:51 UTC (rev 3949)
+++ trunk/components-core/src/main/java/org/dllearner/utilities/owl/OWLClassExpressionToSPARQLConverter.java	2013-05-05 14:24:32 UTC (rev 3950)
@@ -2,6 +2,7 @@
 
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -74,7 +75,7 @@
 	private OWLDataFactory df = new OWLDataFactoryImpl();
 	
 	private Map<Integer, Boolean> intersection;
-	private Set<? extends OWLEntity> variableEntities;
+	private Set<? extends OWLEntity> variableEntities = new HashSet<OWLEntity>();
 	
 	public OWLClassExpressionToSPARQLConverter() {
 	}
@@ -97,6 +98,10 @@
 		return asQuery(rootVariable, expr, Collections.<OWLEntity>emptySet());
 	}
 	
+	public Query asQuery(String rootVariable, OWLClassExpression expr, boolean countQuery){
+		return asQuery(rootVariable, expr, Collections.<OWLEntity>emptySet());
+	}
+	
 	public Query asQuery(String rootVariable, OWLClassExpression expr, Set<? extends OWLEntity> variableEntities){
 		this.variableEntities = variableEntities;
 		String queryString = "SELECT DISTINCT ";
@@ -108,7 +113,7 @@
 				String var = variablesMapping.get(owlEntity);
 				queryString += var + " ";
 			}
-			queryString += "COUNT(" + rootVariable + ") WHERE {";
+			queryString += "(COUNT(DISTINCT " + rootVariable + ") AS ?cnt) WHERE {";
 		}
 		
 		queryString += triplePattern;
@@ -119,10 +124,15 @@
 				String var = variablesMapping.get(owlEntity);
 				queryString += var;
 			}
+			queryString += " ORDER BY DESC(?cnt)";
 		}
 		return QueryFactory.create(queryString, Syntax.syntaxARQ);
 	}
 	
+	public Map<OWLEntity, String> getVariablesMapping() {
+		return variablesMapping;
+	}
+	
 	private void reset(){
 		variablesMapping.clear();
 		variables.clear();

Deleted: trunk/scripts/src/main/java/org/dllearner/scripts/OWLAxiomPatternDetectionEvaluation.java
===================================================================
--- trunk/scripts/src/main/java/org/dllearner/scripts/OWLAxiomPatternDetectionEvaluation.java	2013-05-04 11:27:51 UTC (rev 3949)
+++ trunk/scripts/src/main/java/org/dllearner/scripts/OWLAxiomPatternDetectionEvaluation.java	2013-05-05 14:24:32 UTC (rev 3950)
@@ -1,383 +0,0 @@
-package org.dllearner.scripts;
-
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.prefs.Preferences;
-
-import org.aksw.commons.util.Pair;
-import org.coode.owlapi.functionalparser.OWLFunctionalSyntaxOWLParser;
-import org.dllearner.algorithms.pattern.OWLAxiomPatternFinder;
-import org.dllearner.kb.repository.OntologyRepository;
-import org.dllearner.kb.repository.bioportal.BioPortalRepository;
-import org.dllearner.kb.repository.oxford.OxfordRepository;
-import org.dllearner.kb.repository.tones.TONESRepository;
-import org.ini4j.IniPreferences;
-import org.ini4j.InvalidFileFormatException;
-import org.semanticweb.owlapi.apibinding.OWLManager;
-import org.semanticweb.owlapi.io.OWLObjectRenderer;
-import org.semanticweb.owlapi.io.OWLParserException;
-import org.semanticweb.owlapi.io.StringDocumentSource;
-import org.semanticweb.owlapi.model.OWLAxiom;
-import org.semanticweb.owlapi.model.OWLOntology;
-import org.semanticweb.owlapi.model.OWLOntologyCreationException;
-import org.semanticweb.owlapi.model.UnloadableImportException;
-
-import uk.ac.manchester.cs.owl.owlapi.mansyntaxrenderer.ManchesterOWLSyntaxOWLObjectRendererImpl;
-
-public class OWLAxiomPatternDetectionEvaluation {
-	
-	enum AxiomTypeCategory{
-		TBox, RBox, ABox
-	}
-	
-	private OWLObjectRenderer axiomRenderer = new ManchesterOWLSyntaxOWLObjectRendererImpl();
-	private Connection conn;
-	
-	private boolean fancyLatex = false;
-
-	public OWLAxiomPatternDetectionEvaluation() {
-		initDBConnection();
-	}
-	
-	private void initDBConnection() {
-		try {
-			InputStream is = this.getClass().getClassLoader().getResourceAsStream("db_settings.ini");
-			Preferences prefs = new IniPreferences(is);
-			String dbServer = prefs.node("database").get("server", null);
-			String dbName = prefs.node("database").get("name", null);
-			String dbUser = prefs.node("database").get("user", null);
-			String dbPass = prefs.node("database").get("pass", null);
-
-			Class.forName("com.mysql.jdbc.Driver");
-			String url = "jdbc:mysql://" + dbServer + "/" + dbName;
-			conn = DriverManager.getConnection(url, dbUser, dbPass);
-		} catch (ClassNotFoundException e) {
-			e.printStackTrace();
-		} catch (SQLException e) {
-			e.printStackTrace();
-		} catch (InvalidFileFormatException e) {
-			e.printStackTrace();
-		} catch (FileNotFoundException e) {
-			e.printStackTrace();
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-	}
-	
-	public void run(boolean analyzeRepositories, Collection<OntologyRepository> repositories){
-		//analyze repositories
-		if(analyzeRepositories){
-			analyze(repositories);
-		}
-		
-		//create statistics for the repositories
-		makeRepositoryStatistics(repositories);
-		
-		//get top n TBox, RBox and ABox patterns
-		makePatternStatistics(repositories);
-	}
-	
-	public void run(Collection<OntologyRepository> repositories){
-		run(true, repositories);
-	}
-	
-	private void analyze(Collection<OntologyRepository> repositories){
-		for (OntologyRepository repository : repositories) {
-			repository.initialize();
-			OWLAxiomPatternFinder patternFinder = new OWLAxiomPatternFinder(repository, conn);
-			patternFinder.start();
-		}
-	}
-	
-	private void makePatternStatistics(Collection<OntologyRepository> repositories){
-		int n = 10;
-		
-		String latex = "";
-		
-		//total pattern statistics
-		for (AxiomTypeCategory axiomTypeCategory : AxiomTypeCategory.values()) {
-			Map<OWLAxiom, Pair<Integer, Integer>> topNAxiomPatterns = getTopNAxiomPatterns(axiomTypeCategory, n);
-			latex += asLatex("Top " + n + " " + axiomTypeCategory.name() + " axiom patterns.", topNAxiomPatterns) + "\n\n";
-		}
-		
-		//get top n TBox, RBox and ABox patterns by repository
-		for (OntologyRepository repository : repositories) {
-			for (AxiomTypeCategory axiomTypeCategory : AxiomTypeCategory.values()) {
-				Map<OWLAxiom, Pair<Integer, Integer>> topNAxiomPatterns = getTopNAxiomPatterns(repository, axiomTypeCategory, n);
-				latex += asLatex("Top " + n + " " + axiomTypeCategory.name() + " axiom patterns for " + repository.getName() + " repository.", topNAxiomPatterns) + "\n\n";
-			}
-		}
-		try {
-			new FileOutputStream("pattern-statistics.tex").write(latex.getBytes());
-		} catch (FileNotFoundException e) {
-			e.printStackTrace();
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-	}
-	
-	private void makeRepositoryStatistics(Collection<OntologyRepository> repositories){
-		String latexTable = "\\begin{tabular}{lrr|rrr|rrr|rrr|rrr}";
-		latexTable += "\\toprule\n";
-		latexTable += "Repository & \\multicolumn{2}{c}{\\#Ontologies} & \\multicolumn{12}{c}{\\#Axioms} \\\\\n";
-		latexTable += "& Total & Error & \\multicolumn{3}{c}{Total} & \\multicolumn{3}{c}{Tbox} & \\multicolumn{3}{c}{RBox} & \\multicolumn{3}{c}{Abox} \\\\\\midrule\n";
-		latexTable += "&   &                              & Min & Avg & Max & Min & Avg & Max & Min & Avg & Max & Min & Avg & Max \\\\\\midrule\n";
-        
- 
-		PreparedStatement ps;
-		ResultSet rs;
-		
-		int numberOfOntologies;
-		int numberOfErrorOntologies;
-		int minNumberOfLogicalAxioms;
-		int maxNumberOfLogicalAxioms;
-		int avgNumberOfLogicalAxioms;
-		int minNumberOfTboxAxioms;
-		int maxNumberOfTboxAxioms;
-		int avgNumberOfTboxAxioms;
-		int minNumberOfRboxAxioms;
-		int maxNumberOfRboxAxioms;
-		int avgNumberOfRboxAxioms;
-		int minNumberOfAboxAxioms;
-		int maxNumberOfAboxAxioms;
-		int avgNumberOfAboxAxioms;
-		
-		//for each repository
-		for (OntologyRepository repository : repositories) {
-			try {
-				//get number of ontologies
-				ps = conn.prepareStatement("SELECT COUNT(*) FROM Ontology WHERE repository=?");
-				ps.setString(1, repository.getName());
-				numberOfOntologies = count(ps);
-				//get number of error causing ontologies
-				ps = conn.prepareStatement("SELECT COUNT(*) FROM Ontology WHERE repository=? AND iri LIKE 'ERROR%'");
-				ps.setString(1, repository.getName());
-				numberOfErrorOntologies = count(ps);
-				//get min number of logical axioms
-				ps = conn.prepareStatement("SELECT MIN(logical_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
-				ps.setString(1, repository.getName());
-				minNumberOfLogicalAxioms  = count(ps);
-				//get max number of logical axioms
-				ps = conn.prepareStatement("SELECT MAX(logical_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
-				ps.setString(1, repository.getName());
-				maxNumberOfLogicalAxioms  = count(ps);
-				//get avg number of logical axioms
-				ps = conn.prepareStatement("SELECT AVG(logical_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
-				ps.setString(1, repository.getName());
-				avgNumberOfLogicalAxioms = count(ps);
-				//get min number of tbox axioms
-				ps = conn.prepareStatement("SELECT MIN(tbox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
-				ps.setString(1, repository.getName());
-				minNumberOfTboxAxioms = count(ps);
-				//get max number of tbox axioms
-				ps = conn.prepareStatement("SELECT MAX(tbox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
-				ps.setString(1, repository.getName());
-				maxNumberOfTboxAxioms = count(ps);
-				//get avg number of tbox axioms
-				ps = conn.prepareStatement("SELECT AVG(tbox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
-				ps.setString(1, repository.getName());
-				avgNumberOfTboxAxioms = count(ps);
-				//get min number of rbox axioms
-				ps = conn.prepareStatement("SELECT MIN(rbox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
-				ps.setString(1, repository.getName());
-				minNumberOfRboxAxioms = count(ps);
-				//get max number of rbox axioms
-				ps = conn.prepareStatement("SELECT MAX(rbox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
-				ps.setString(1, repository.getName());
-				maxNumberOfRboxAxioms = count(ps);
-				//get avg number of rbox axioms
-				ps = conn.prepareStatement("SELECT AVG(rbox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
-				ps.setString(1, repository.getName());
-				avgNumberOfRboxAxioms = count(ps);
-				//get min number of abox axioms
-				ps = conn.prepareStatement("SELECT MIN(abox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
-				ps.setString(1, repository.getName());
-				minNumberOfAboxAxioms = count(ps);
-				//get max number of abox axioms
-				ps = conn.prepareStatement("SELECT MAX(abox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
-				ps.setString(1, repository.getName());
-				maxNumberOfAboxAxioms = count(ps);
-				//get avg number of abox axioms
-				ps = conn.prepareStatement("SELECT AVG(abox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
-				ps.setString(1, repository.getName());
-				avgNumberOfAboxAxioms = count(ps);
-				
-				latexTable += 
-						repository.getName() + "&" + 
-						numberOfOntologies + "&" +
-						numberOfErrorOntologies + "&" +
-						minNumberOfLogicalAxioms + "&" +
-						avgNumberOfLogicalAxioms + "&" +
-						maxNumberOfLogicalAxioms + "&" +
-						minNumberOfTboxAxioms + "&" +
-						avgNumberOfTboxAxioms + "&" +
-						maxNumberOfTboxAxioms + "&" +
-						minNumberOfRboxAxioms + "&" +
-						avgNumberOfRboxAxioms + "&" +
-						maxNumberOfRboxAxioms + "&" +
-						minNumberOfAboxAxioms + "&" +
-						avgNumberOfAboxAxioms + "&" +
-						maxNumberOfAboxAxioms + "\\\\\n";
-				
-			} catch (SQLException e) {
-				e.printStackTrace();
-			}
-		}
-		latexTable += "\\bottomrule\\end{tabular}";
-		try {
-			new FileOutputStream("repository-statistics.tex").write(latexTable.getBytes());
-		} catch (FileNotFoundException e) {
-			e.printStackTrace();
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-	}
-	
-	private String asLatex(String title, Map<OWLAxiom, Pair<Integer, Integer>> topN){
-		String latexTable = "\\begin{table}\n";
-		latexTable += "\\begin{tabular}{lrr}\n";
-		latexTable += "\\toprule\n";
-		latexTable += "Pattern & Frequency & \\#Ontologies\\\\\\midrule\n";
-		
-		for (Entry<OWLAxiom, Pair<Integer, Integer>> entry : topN.entrySet()) {
-			OWLAxiom axiom = entry.getKey();
-			Integer frequency = entry.getValue().getKey();
-			Integer idf = entry.getValue().getValue();
-			
-			if(axiom != null){
-				String axiomColumn = axiomRenderer.render(axiom);
-				if(fancyLatex){
-					axiomColumn = "\\begin{lstlisting}[language=manchester]" + axiomColumn + "\\end{lstlisting}";
-				}
-				latexTable += axiomColumn + " & " + frequency + " & " + idf + "\\\\\n";
-			}
-		}
-		latexTable += "\\bottomrule\n\\end{tabular}\n";
-		latexTable += "\\caption{" + title + "}\n";
-		latexTable += "\\end{table}\n";
-		return latexTable;
-	}
-	
-	private Map<OWLAxiom, Pair<Integer, Integer>> getTopNAxiomPatterns(AxiomTypeCategory axiomType, int n){
-		Map<OWLAxiom, Pair<Integer, Integer>> topN = new LinkedHashMap<OWLAxiom, Pair<Integer, Integer>>();
-		PreparedStatement ps;
-		ResultSet rs;
-		try {
-			ps = conn.prepareStatement("SELECT pattern,SUM(occurrences),COUNT(ontology_id) FROM " +
-					"Ontology_Pattern OP, Pattern P, Ontology O WHERE " +
-					"(P.id=OP.pattern_id AND O.id=OP.ontology_id AND P.axiom_type=?) " +
-					"GROUP BY P.id ORDER BY SUM(`OP`.`occurrences`) DESC LIMIT ?");
-			ps.setString(1, axiomType.name());
-			ps.setInt(2, n);
-			rs = ps.executeQuery();
-			while(rs.next()){
-				topN.put(asOWLAxiom(rs.getString(1)), new Pair<Integer, Integer>(rs.getInt(2), rs.getInt(3)));
-			}
-		} catch(SQLException e){
-			e.printStackTrace();
-		}
-		return topN;
-	}
-	
-	private Map<OWLAxiom, Pair<Integer, Integer>> getTopNAxiomPatterns(OntologyRepository repository, AxiomTypeCategory axiomType, int n){
-		Map<OWLAxiom, Pair<Integer, Integer>> topN = new LinkedHashMap<OWLAxiom, Pair<Integer, Integer>>();
-		PreparedStatement ps;
-		ResultSet rs;
-		try {
-			//get number of ontologies
-			ps = conn.prepareStatement("SELECT pattern,SUM(occurrences),COUNT(ontology_id) FROM " +
-					"Ontology_Pattern OP, Pattern P, Ontology O WHERE " +
-					"(P.id=OP.pattern_id AND O.id=OP.ontology_id AND O.repository=? AND P.axiom_type=?) " +
-					"GROUP BY P.id ORDER BY SUM(`OP`.`occurrences`) DESC LIMIT ?");
-			ps.setString(1, repository.getName());
-			ps.setString(2, axiomType.name());
-			ps.setInt(3, n);
-			rs = ps.executeQuery();
-			while(rs.next()){
-				topN.put(asOWLAxiom(rs.getString(1)), new Pair<Integer, Integer>(rs.getInt(2), rs.getInt(3)));
-			}
-		} catch(SQLException e){
-			e.printStackTrace();
-		}
-		return topN;
-	}
-	
-	private Map<OntologyRepository, Map<OWLAxiom, Integer>> getTopNAxiomPatterns(Collection<OntologyRepository> repositories, AxiomTypeCategory axiomType, int n){
-		Map<OntologyRepository, Map<OWLAxiom, Integer>> topNByRepository = new LinkedHashMap<OntologyRepository, Map<OWLAxiom,Integer>>();
-		PreparedStatement ps;
-		ResultSet rs;
-		//for each repository
-		for (OntologyRepository repository : repositories) {
-			Map<OWLAxiom, Integer> topN = new LinkedHashMap<OWLAxiom, Integer>();
-			try {
-				//get number of ontologies
-				ps = conn.prepareStatement("SELECT pattern,SUM(occurrences) FROM " +
-						"Ontology_Pattern OP, Pattern P, Ontology O WHERE " +
-						"(P.id=OP.pattern_id AND O.id=OP.ontology_id AND O.repository=? AND P.axiom_type=?) " +
-						"GROUP BY P.id ORDER BY SUM(`OP`.`occurrences`) DESC LIMIT ?");
-				ps.setString(1, repository.getName());
-				ps.setString(2, "RBox");
-				ps.setInt(3, n);
-				rs = ps.executeQuery();
-				while(rs.next()){
-					topN.put(asOWLAxiom(rs.getString(1)), rs.getInt(2));
-				}
-			} catch(SQLException e){
-				e.printStackTrace();
-			}
-			topNByRepository.put(repository, topN);
-		}
-		return topNByRepository;
-	}
-	
-	private OWLAxiom asOWLAxiom(String functionalSyntaxAxiomString){
-		try {
-			StringDocumentSource s = new StringDocumentSource("Ontology(<http://www.pattern.org> " + functionalSyntaxAxiomString + ")");
-			OWLFunctionalSyntaxOWLParser p = new OWLFunctionalSyntaxOWLParser();
-			OWLOntology newOntology = OWLManager.createOWLOntologyManager().createOntology();
-			p.parse(s, newOntology);
-			if(!newOntology.getLogicalAxioms().isEmpty()){
-				return newOntology.getLogicalAxioms().iterator().next();
-			}
-		} catch (UnloadableImportException e) {
-			e.printStackTrace();
-		} catch (OWLOntologyCreationException e) {
-			e.printStackTrace();
-		} catch (OWLParserException e) {
-			System.err.println("Parsing failed for axiom " + functionalSyntaxAxiomString);
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-		return null;
-	}
-	
-	private int count(PreparedStatement ps) throws SQLException{
-		ResultSet rs = ps.executeQuery();
-		rs.next();
-		return rs.getInt(1);
-	}
-	
-	public static void main(String[] args) throws Exception {
-//		ToStringRenderer.getInstance().setRenderer(new DLSyntaxObjectRenderer());
-		boolean analyzeRepositories = true;
-		if(args.length == 1){
-			analyzeRepositories = Boolean.parseBoolean(args[0]);
-		}
-		new OWLAxiomPatternDetectionEvaluation().run(analyzeRepositories, Arrays.asList(
-				new TONESRepository(), new BioPortalRepository(), new OxfordRepository()));
-	}
-	
-
-}

Added: trunk/scripts/src/main/java/org/dllearner/scripts/pattern/OWLAxiomPatternDetectionEvaluation.java
===================================================================
--- trunk/scripts/src/main/java/org/dllearner/scripts/pattern/OWLAxiomPatternDetectionEvaluation.java	                        (rev 0)
+++ trunk/scripts/src/main/java/org/dllearner/scripts/pattern/OWLAxiomPatternDetectionEvaluation.java	2013-05-05 14:24:32 UTC (rev 3950)
@@ -0,0 +1,408 @@
+package org.dllearner.scripts.pattern;
+
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.prefs.Preferences;
+
+import org.aksw.commons.util.Pair;
+import org.coode.owlapi.functionalparser.OWLFunctionalSyntaxOWLParser;
+import org.dllearner.algorithms.pattern.OWLAxiomPatternFinder;
+import org.dllearner.core.owl.NamedClass;
+import org.dllearner.kb.SparqlEndpointKS;
+import org.dllearner.kb.repository.OntologyRepository;
+import org.dllearner.kb.repository.bioportal.BioPortalRepository;
+import org.dllearner.kb.repository.oxford.OxfordRepository;
+import org.dllearner.kb.repository.tones.TONESRepository;
+import org.dllearner.kb.sparql.SparqlEndpoint;
+import org.dllearner.reasoning.SPARQLReasoner;
+import org.dllearner.utilities.owl.OWLClassExpressionToSPARQLConverter;
+import org.ini4j.IniPreferences;
+import org.ini4j.InvalidFileFormatException;
+import org.semanticweb.owlapi.apibinding.OWLManager;
+import org.semanticweb.owlapi.io.OWLObjectRenderer;
+import org.semanticweb.owlapi.io.OWLParserException;
+import org.semanticweb.owlapi.io.StringDocumentSource;
+import org.semanticweb.owlapi.model.AxiomType;
+import org.semanticweb.owlapi.model.OWLAxiom;
+import org.semanticweb.owlapi.model.OWLClassExpression;
+import org.semanticweb.owlapi.model.OWLDataFactory;
+import org.semanticweb.owlapi.model.OWLOntology;
+import org.semanticweb.owlapi.model.OWLOntologyCreationException;
+import org.semanticweb.owlapi.model.OWLSubClassOfAxiom;
+import org.semanticweb.owlapi.model.UnloadableImportException;
+
+import com.hp.hpl.jena.query.Query;
+
+import uk.ac.manchester.cs.owl.owlapi.OWLDataFactoryImpl;
+import uk.ac.manchester.cs.owl.owlapi.mansyntaxrenderer.ManchesterOWLSyntaxOWLObjectRendererImpl;
+
+public class OWLAxiomPatternDetectionEvaluation {
+	
+	enum AxiomTypeCategory{
+		TBox, RBox, ABox
+	}
+	
+	private OWLObjectRenderer axiomRenderer = new ManchesterOWLSyntaxOWLObjectRendererImpl();
+	private OWLDataFactory df = new OWLDataFactoryImpl();
+	private Connection conn;
+	
+	private boolean fancyLatex = false;
+
+	public OWLAxiomPatternDetectionEvaluation() {
+		initDBConnection();
+	}
+	
+	private void initDBConnection() {
+		try {
+			InputStream is = this.getClass().getClassLoader().getResourceAsStream("db_settings.ini");
+			Preferences prefs = new IniPreferences(is);
+			String dbServer = prefs.node("database").get("server", null);
+			String dbName = prefs.node("database").get("name", null);
+			String dbUser = prefs.node("database").get("user", null);
+			String dbPass = prefs.node("database").get("pass", null);
+
+			Class.forName("com.mysql.jdbc.Driver");
+			String url = "jdbc:mysql://" + dbServer + "/" + dbName;
+			conn = DriverManager.getConnection(url, dbUser, dbPass);
+		} catch (ClassNotFoundException e) {
+			e.printStackTrace();
+		} catch (SQLException e) {
+			e.printStackTrace();
+		} catch (InvalidFileFormatException e) {
+			e.printStackTrace();
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public void run(boolean analyzeRepositories, Collection<OntologyRepository> repositories){
+		//analyze repositories
+		if(analyzeRepositories){
+			analyze(repositories);
+		}
+		
+		//create statistics for the repositories
+		makeRepositoryStatistics(repositories);
+		
+		//get top n TBox, RBox and ABox patterns
+		makePatternStatistics(repositories);
+	}
+	
+	public void run(Collection<OntologyRepository> repositories){
+		run(true, repositories);
+	}
+	
+	public List<OWLAxiom> getPatternsToEvaluate(){
+		List<OWLAxiom> axiomPatterns = new ArrayList<OWLAxiom>();
+		
+		Map<OWLAxiom, Pair<Integer, Integer>> topNAxiomPatterns = getTopNAxiomPatterns(AxiomTypeCategory.TBox, 10);
+		axiomPatterns.addAll(topNAxiomPatterns.keySet());
+		
+		return axiomPatterns;
+	}
+	
+	private void analyze(Collection<OntologyRepository> repositories){
+		for (OntologyRepository repository : repositories) {
+			repository.initialize();
+			OWLAxiomPatternFinder patternFinder = new OWLAxiomPatternFinder(repository, conn);
+			patternFinder.start();
+		}
+	}
+	
+	private void makePatternStatistics(Collection<OntologyRepository> repositories){
+		int n = 10;
+		
+		String latex = "";
+		
+		//total pattern statistics
+		for (AxiomTypeCategory axiomTypeCategory : AxiomTypeCategory.values()) {
+			Map<OWLAxiom, Pair<Integer, Integer>> topNAxiomPatterns = getTopNAxiomPatterns(axiomTypeCategory, n);
+			latex += asLatex("Top " + n + " " + axiomTypeCategory.name() + " axiom patterns.", topNAxiomPatterns) + "\n\n";
+		}
+		
+		//get top n TBox, RBox and ABox patterns by repository
+		for (OntologyRepository repository : repositories) {
+			for (AxiomTypeCategory axiomTypeCategory : AxiomTypeCategory.values()) {
+				Map<OWLAxiom, Pair<Integer, Integer>> topNAxiomPatterns = getTopNAxiomPatterns(repository, axiomTypeCategory, n);
+				latex += asLatex("Top " + n + " " + axiomTypeCategory.name() + " axiom patterns for " + repository.getName() + " repository.", topNAxiomPatterns) + "\n\n";
+			}
+		}
+		try {
+			new FileOutputStream("pattern-statistics.tex").write(latex.getBytes());
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	private void makeRepositoryStatistics(Collection<OntologyRepository> repositories){
+		String latexTable = "\\begin{tabular}{lrr|rrr|rrr|rrr|rrr}";
+		latexTable += "\\toprule\n";
+		latexTable += "Repository & \\multicolumn{2}{c}{\\#Ontologies} & \\multicolumn{12}{c}{\\#Axioms} \\\\\n";
+		latexTable += "& Total & Error & \\multicolumn{3}{c}{Total} & \\multicolumn{3}{c}{Tbox} & \\multicolumn{3}{c}{RBox} & \\multicolumn{3}{c}{Abox} \\\\\\midrule\n";
+		latexTable += "&   &                              & Min & Avg & Max & Min & Avg & Max & Min & Avg & Max & Min & Avg & Max \\\\\\midrule\n";
+        
+ 
+		PreparedStatement ps;
+		ResultSet rs;
+		
+		int numberOfOntologies;
+		int numberOfErrorOntologies;
+		int minNumberOfLogicalAxioms;
+		int maxNumberOfLogicalAxioms;
+		int avgNumberOfLogicalAxioms;
+		int minNumberOfTboxAxioms;
+		int maxNumberOfTboxAxioms;
+		int avgNumberOfTboxAxioms;
+		int minNumberOfRboxAxioms;
+		int maxNumberOfRboxAxioms;
+		int avgNumberOfRboxAxioms;
+		int minNumberOfAboxAxioms;
+		int maxNumberOfAboxAxioms;
+		int avgNumberOfAboxAxioms;
+		
+		//for each repository
+		for (OntologyRepository repository : repositories) {
+			try {
+				//get number of ontologies
+				ps = conn.prepareStatement("SELECT COUNT(*) FROM Ontology WHERE repository=?");
+				ps.setString(1, repository.getName());
+				numberOfOntologies = count(ps);
+				//get number of error causing ontologies
+				ps = conn.prepareStatement("SELECT COUNT(*) FROM Ontology WHERE repository=? AND iri LIKE 'ERROR%'");
+				ps.setString(1, repository.getName());
+				numberOfErrorOntologies = count(ps);
+				//get min number of logical axioms
+				ps = conn.prepareStatement("SELECT MIN(logical_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
+				ps.setString(1, repository.getName());
+				minNumberOfLogicalAxioms  = count(ps);
+				//get max number of logical axioms
+				ps = conn.prepareStatement("SELECT MAX(logical_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
+				ps.setString(1, repository.getName());
+				maxNumberOfLogicalAxioms  = count(ps);
+				//get avg number of logical axioms
+				ps = conn.prepareStatement("SELECT AVG(logical_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
+				ps.setString(1, repository.getName());
+				avgNumberOfLogicalAxioms = count(ps);
+				//get min number of tbox axioms
+				ps = conn.prepareStatement("SELECT MIN(tbox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
+				ps.setString(1, repository.getName());
+				minNumberOfTboxAxioms = count(ps);
+				//get max number of tbox axioms
+				ps = conn.prepareStatement("SELECT MAX(tbox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
+				ps.setString(1, repository.getName());
+				maxNumberOfTboxAxioms = count(ps);
+				//get avg number of tbox axioms
+				ps = conn.prepareStatement("SELECT AVG(tbox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
+				ps.setString(1, repository.getName());
+				avgNumberOfTboxAxioms = count(ps);
+				//get min number of rbox axioms
+				ps = conn.prepareStatement("SELECT MIN(rbox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
+				ps.setString(1, repository.getName());
+				minNumberOfRboxAxioms = count(ps);
+				//get max number of rbox axioms
+				ps = conn.prepareStatement("SELECT MAX(rbox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
+				ps.setString(1, repository.getName());
+				maxNumberOfRboxAxioms = count(ps);
+				//get avg number of rbox axioms
+				ps = conn.prepareStatement("SELECT AVG(rbox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
+				ps.setString(1, repository.getName());
+				avgNumberOfRboxAxioms = count(ps);
+				//get min number of abox axioms
+				ps = conn.prepareStatement("SELECT MIN(abox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
+				ps.setString(1, repository.getName());
+				minNumberOfAboxAxioms = count(ps);
+				//get max number of abox axioms
+				ps = conn.prepareStatement("SELECT MAX(abox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
+				ps.setString(1, repository.getName());
+				maxNumberOfAboxAxioms = count(ps);
+				//get avg number of abox axioms
+				ps = conn.prepareStatement("SELECT AVG(abox_axioms) FROM Ontology WHERE repository=? AND iri NOT LIKE 'ERROR%'");
+				ps.setString(1, repository.getName());
+				avgNumberOfAboxAxioms = count(ps);
+				
+				latexTable += 
+						repository.getName() + "&" + 
+						numberOfOntologies + "&" +
+						numberOfErrorOntologies + "&" +
+						minNumberOfLogicalAxioms + "&" +
+						avgNumberOfLogicalAxioms + "&" +
+						maxNumberOfLogicalAxioms + "&" +
+						minNumberOfTboxAxioms + "&" +
+						avgNumberOfTboxAxioms + "&" +
+						maxNumberOfTboxAxioms + "&" +
+						minNumberOfRboxAxioms + "&" +
+						avgNumberOfRboxAxioms + "&" +
+						maxNumberOfRboxAxioms + "&" +
+						minNumberOfAboxAxioms + "&" +
+						avgNumberOfAboxAxioms + "&" +
+						maxNumberOfAboxAxioms + "\\\\\n";
+				
+			} catch (SQLException e) {
+				e.printStackTrace();
+			}
+		}
+		latexTable += "\\bottomrule\\end{tabular}";
+		try {
+			new FileOutputStream("repository-statistics.tex").write(latexTable.getBytes());
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	private String asLatex(String title, Map<OWLAxiom, Pair<Integer, Integer>> topN){
+		String latexTable = "\\begin{table}\n";
+		latexTable += "\\begin{tabular}{lrr}\n";
+		latexTable += "\\toprule\n";
+		latexTable += "Pattern & Frequency & \\#Ontologies\\\\\\midrule\n";
+		
+		for (Entry<OWLAxiom, Pair<Integer, Integer>> entry : topN.entrySet()) {
+			OWLAxiom axiom = entry.getKey();
+			Integer frequency = entry.getValue().getKey();
+			Integer idf = entry.getValue().getValue();
+			
+			if(axiom != null){
+				String axiomColumn = axiomRenderer.render(axiom);
+				if(fancyLatex){
+					axiomColumn = "\\begin{lstlisting}[language=manchester]" + axiomColumn + "\\end{lstlisting}";
+				}
+				latexTable += axiomColumn + " & " + frequency + " & " + idf + "\\\\\n";
+			}
+		}
+		latexTable += "\\bottomrule\n\\end{tabular}\n";
+		latexTable += "\\caption{" + title + "}\n";
+		latexTable += "\\end{table}\n";
+		return latexTable;
+	}
+	
+	private Map<OWLAxiom, Pair<Integer, Integer>> getTopNAxiomPatterns(AxiomTypeCategory axiomType, int n){
+		Map<OWLAxiom, Pair<Integer, Integer>> topN = new LinkedHashMap<OWLAxiom, Pair<Integer, Integer>>();
+		PreparedStatement ps;
+		ResultSet rs;
+		try {
+			ps = conn.prepareStatement("SELECT pattern,SUM(occurrences),COUNT(ontology_id) FROM " +
+					"Ontology_Pattern OP, Pattern P, Ontology O WHERE " +
+					"(P.id=OP.pattern_id AND O.id=OP.ontology_id AND P.axiom_type=?) " +
+					"GROUP BY P.id ORDER BY SUM(`OP`.`occurrences`) DESC LIMIT ?");
+			ps.setString(1, axiomType.name());
+			ps.setInt(2, n);
+			rs = ps.executeQuery();
+			while(rs.next()){
+				topN.put(asOWLAxiom(rs.getString(1)), new Pair<Integer, Integer>(rs.getInt(2), rs.getInt(3)));
+			}
+		} catch(SQLException e){
+			e.printStackTrace();
+		}
+		return topN;
+	}
+	
+	private Map<OWLAxiom, Pair<Integer, Integer>> getTopNAxiomPatterns(OntologyRepository repository, AxiomTypeCategory axiomType, int n){
+		Map<OWLAxiom, Pair<Integer, Integer>> topN = new LinkedHashMap<OWLAxiom, Pair<Integer, Integer>>();
+		PreparedStatement ps;
+		ResultSet rs;
+		try {
+			//get number of ontologies
+			ps = conn.prepareStatement("SELECT pattern,SUM(occurrences),COUNT(ontology_id) FROM " +
+					"Ontology_Pattern OP, Pattern P, Ontology O WHERE " +
+					"(P.id=OP.pattern_id AND O.id=OP.ontology_id AND O.repository=? AND P.axiom_type=?) " +
+					"GROUP BY P.id ORDER BY SUM(`OP`.`occurrences`) DESC LIMIT ?");
+			ps.setString(1, repository.getName());
+			ps.setString(2, axiomType.name());
+			ps.setInt(3, n);
+			rs = ps.executeQuery();
+			while(rs.next()){
+				topN.put(asOWLAxiom(rs.getString(1)), new Pair<Integer, Integer>(rs.getInt(2), rs.getInt(3)));
+			}
+		} catch(SQLException e){
+			e.printStackTrace();
+		}
+		return topN;
+	}
+	
+	private Map<OntologyRepository, Map<OWLAxiom, Integer>> getTopNAxiomPatterns(Collection<OntologyRepository> repositories, AxiomTypeCategory axiomType, int n){
+		Map<OntologyRepository, Map<OWLAxiom, Integer>> topNByRepository = new LinkedHashMap<OntologyRepository, Map<OWLAxiom,Integer>>();
+		PreparedStatement ps;
+		ResultSet rs;
+		//for each repository
+		for (OntologyRepository repository : repositories) {
+			Map<OWLAxiom, Integer> topN = new LinkedHashMap<OWLAxiom, Integer>();
+			try {
+				//get number of ontologies
+				ps = conn.prepareStatement("SELECT pattern,SUM(occurrences) FROM " +
+						"Ontology_Pattern OP, Pattern P, Ontology O WHERE " +
+						"(P.id=OP.pattern_id AND O.id=OP.ontology_id AND O.repository=? AND P.axiom_type=?) " +
+						"GROUP BY P.id ORDER BY SUM(`OP`.`occurrences`) DESC LIMIT ?");
+				ps.setString(1, repository.getName());
+				ps.setString(2, "RBox");
+				ps.setInt(3, n);
+				rs = ps.executeQuery();
+				while(rs.next()){
+					topN.put(asOWLAxiom(rs.getString(1)), rs.getInt(2));
+				}
+			} catch(SQLException e){
+				e.printStackTrace();
+			}
+			topNByRepository.put(repository, topN);
+		}
+		return topNByRepository;
+	}
+	
+	private OWLAxiom asOWLAxiom(String functionalSyntaxAxiomString){
+		try {
+			StringDocumentSource s = new StringDocumentSource("Ontology(<http://www.pattern.org> " + functionalSyntaxAxiomString + ")");
+			OWLFunctionalSyntaxOWLParser p = new OWLFunctionalSyntaxOWLParser();
+			OWLOntology newOntology = OWLManager.createOWLOntologyManager().createOntology();
+			p.parse(s, newOntology);
+			if(!newOntology.getLogicalAxioms().isEmpty()){
+				return newOntology.getLogicalAxioms().iterator().next();
+			}
+		} catch (UnloadableImportException e) {
+			e.printStackTrace();
+		} catch (OWLOntologyCreationException e) {
+			e.printStackTrace();
+		} catch (OWLParserException e) {
+			System.err.println("Parsing failed for axiom " + functionalSyntaxAxiomString);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	private int count(PreparedStatement ps) throws SQLException{
+		ResultSet rs = ps.executeQuery();
+		rs.next();
+		return rs.getInt(1);
+	}
+	
+	public static void main(String[] args) throws Exception {
+//		ToStringRenderer.getInstance().setRenderer(new DLSyntaxObjectRenderer());
+		boolean analyzeRepositories = true;
+		if(args.length == 1){
+			analyzeRepositories = Boolean.parseBoolean(args[0]);
+		}
+		new OWLAxiomPatternDetectionEvaluation().run(analyzeRepositories, Arrays.asList(
+				new TONESRepository(), new BioPortalRepository(), new OxfordRepository()));
+	}
+	
+
+}

Added: trunk/scripts/src/main/java/org/dllearner/scripts/pattern/OWLAxiomPatternUsageEvaluation.java
===================================================================
--- trunk/scripts/src/main/java/org/dllearner/scripts/pattern/OWLAxiomPatternUsageEvaluation.java	                        (rev 0)
+++ trunk/scripts/src/main/java/org/dllearner/scripts/pattern/OWLAxiomPatternUsageEvaluation.java	2013-05-05 14:24:32 UTC (rev 3950)
@@ -0,0 +1,418 @@
+package org.dllearner.scripts.pattern;
+
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.SocketTimeoutException;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.prefs.Preferences;
+
+import org.aksw.commons.util.Pair;
+import org.apache.log4j.Logger;
+import org.coode.owlapi.functionalparser.OWLFunctionalSyntaxOWLParser;
+import org.coode.owlapi.turtle.TurtleOntologyFormat;
+import org.dllearner.core.EvaluatedAxiom;
+import org.dllearner.core.Score;
+import org.dllearner.core.owl.NamedClass;
+import org.dllearner.kb.LocalModelBasedSparqlEndpointKS;
+import org.dllearner.kb.SparqlEndpointKS;
+import org.dllearner.kb.sparql.ExtractionDBCache;
+import org.dllearner.kb.sparql.SparqlEndpoint;
+import org.dllearner.kb.sparql.SparqlQuery;
+import org.dllearner.learningproblems.AxiomScore;
+import org.dllearner.learningproblems.Heuristics;
+import org.dllearner.reasoning.SPARQLReasoner;
+import org.dllearner.utilities.owl.DLLearnerAxiomConvertVisitor;
+import org.dllearner.utilities.owl.OWLClassExpressionToSPARQLConverter;
+import org.ini4j.IniPreferences;
+import org.ini4j.InvalidFileFormatException;
+import org.semanticweb.owlapi.apibinding.OWLManager;
+import org.semanticweb.owlapi.io.OWLObjectRenderer;
+import org.semanticweb.owlapi.io.OWLParserException;
+import org.semanticweb.owlapi.io.StringDocumentSource;
+import org.semanticweb.owlapi.io.ToStringRenderer;
+import org.semanticweb.owlapi.model.AxiomType;
+import org.semanticweb.owlapi.model.IRI;
+import org.semanticweb.owlapi.model.OWLAnnotationProperty;
+import org.semanticweb.owlapi.model.OWLAxiom;
+import org.semanticweb.owlapi.model.OWLClass;
+import org.semanticweb.owlapi.model.OWLClassExpression;
+import org.semanticweb.owlapi.model.OWLDataFactory;
+import org.semanticweb.owlapi.model.OWLEntity;
+import org.semanticweb.owlapi.model.OWLOntology;
+import org.semanticweb.owlapi.model.OWLOntologyCreationException;
+import org.semanticweb.owlapi.model.OWLOntologyManager;
+import org.semanticweb.owlapi.model.OWLOntologyStorageException;
+import org.semanticweb.owlapi.model.OWLSubClassOfAxiom;
+import org.semanticweb.owlapi.model.UnloadableImportException;
+import org.semanticweb.owlapi.util.OWLObjectDuplicator;
+
+import uk.ac.manchester.cs.owl.owlapi.OWLDataFactoryImpl;
+import uk.ac.manchester.cs.owl.owlapi.mansyntaxrenderer.ManchesterOWLSyntaxOWLObjectRendererImpl;
+import uk.ac.manchester.cs.owlapi.dlsyntax.DLSyntaxObjectRenderer;
+
+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.query.QuerySolution;
+import com.hp.hpl.jena.query.Syntax;
+import com.hp.hpl.jena.rdf.model.Resource;
+import com.hp.hpl.jena.sparql.engine.http.QueryEngineHTTP;
+import com.hp.hpl.jena.sparql.engine.http.QueryExceptionHTTP;
+
+public class OWLAxiomPatternUsageEvaluation {
+	
+	
+	private static final Logger logger = Logger.getLogger(OWLAxiomPatternUsageEvaluation.AxiomTypeCategory.class
+			.getName());
+	
+	enum AxiomTypeCategory{
+		TBox, RBox, ABox
+	}
+	
+	private OWLObjectRenderer axiomRenderer = new ManchesterOWLSyntaxOWLObjectRendererImpl();
+	private OWLDataFactory df = new OWLDataFactoryImpl();
+	private Connection conn;
+	
+	private ExtractionDBCache cache = new ExtractionDBCache("pattern-cache");
+	private SparqlEndpointKS ks = new SparqlEndpointKS(SparqlEndpoint.getEndpointDBpedia(), cache);//new LocalModelBasedSparqlEndpointKS(model);
+	private String ns = "http://dbpedia.org/ontology/";
+	
+	private boolean fancyLatex = false;
+	private DecimalFormat format = new DecimalFormat("00.0%");
+	private long waitingTime = TimeUnit.SECONDS.toMillis(3);
+	private double threshold = 0.6;
+	private OWLAnnotationProperty confidenceProperty = df.getOWLAnnotationProperty(IRI.create("http://dl-learner.org/pattern/confidence"));
+
+	public OWLAxiomPatternUsageEvaluation() {
+		initDBConnection();
+	}
+	
+	private void initDBConnection() {
+		try {
+			InputStream is = this.getClass().getClassLoader().getResourceAsStream("db_settings.ini");
+			Preferences prefs = new IniPreferences(is);
+			String dbServer = prefs.node("database").get("server", null);
+			String dbName = prefs.node("database").get("name", null);
+			String dbUser = prefs.node("database").get("user", null);
+			String dbPass = prefs.node("database").get("pass", null);
+
+			Class.forName("com.mysql.jdbc.Driver");
+			String url = "jdbc:mysql://" + dbServer + "/" + dbName;
+			conn = DriverManager.getConnection(url, dbUser, dbPass);
+		} catch (ClassNotFoundException e) {
+			e.printStackTrace();
+		} catch (SQLException e) {
+			e.printStackTrace();
+		} catch (InvalidFileFormatException e) {
+			e.printStackTrace();
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public void run(){
+		SPARQLReasoner reasoner = new SPARQLReasoner(ks, cache);
+		
+		OWLClassExpressionToSPARQLConverter converter = new OWLClassExpressionToSPARQLConverter();
+		
+		//get the axiom patterns to evaluate
+		List<OWLAxiom> patterns = getPatternsToEvaluate();
+		
+		//get all classes in KB
+		Set<NamedClass> classes = reasoner.getTypes(ns);
+		
+		//for each pattern
+		for (OWLAxiom pattern : patterns) {
+			if(pattern.isOfType(AxiomType.SUBCLASS_OF)){
+				logger.info("Processing " + pattern + "...");
+				Set<EvaluatedAxiom> evaluatedAxioms = new HashSet<EvaluatedAxiom>();
+				Map<OWLAxiom, Score> axioms2Score = new LinkedHashMap<OWLAxiom, Score>();
+				OWLClassExpression patternSubClass = ((OWLSubClassOfAxiom)pattern).getSubClass();
+				OWLClassExpression superClass = ((OWLSubClassOfAxiom)pattern).getSuperClass();
+				//for each class
+				int i = 1;
+				for (NamedClass cls : classes) {
+					logger.info("Processing " + cls + "...");
+					//set the subclass as a class from the KB
+					OWLClass subClass = df.getOWLClass(IRI.create(cls.getName()));
+					
+					//1. count number of instances in subclass expression
+					Query query = QueryFactory.create("SELECT (COUNT(DISTINCT ?x) AS ?cnt) WHERE {" + converter.convert("?x", subClass) + "}",Syntax.syntaxARQ);
+					int subClassCnt = executeSelectQuery(query).next().getLiteral("cnt").getInt(); 
+					
+					//2. count number of instances in subclass AND superclass expression
+					//we have 2 options here to evaluate the whole axiom pattern:
+					//a) we replace all entities in the signature of the super class expression(except the subclass) with variables 
+					//and GROUP BY them
+					//b) we replace only 1 entity with a variable, thus we have to try it for several combinations
+//					for (OWLEntity entity : signature) {
+//						//replace current entity with variable and for the rest use existing entities in KB
+//						query = converter.asQuery("?x", df.getOWLObjectIntersectionOf(subClass, superClass), signature);
+//					}
+					Set<OWLEntity> signature = superClass.getSignature();
+					signature.remove(subClass);
+					query = converter.asQuery("?x", df.getOWLObjectIntersectionOf(subClass, superClass), signature);
+					query.setLimit(100);
+					Map<OWLEntity, String> variablesMapping = converter.getVariablesMapping();System.out.println(query);
+					com.hp.hpl.jena.query.ResultSet rs = executeSelectQuery(query);
+					QuerySolution qs;
+					while(rs.hasNext()){
+						qs = rs.next();
+						//get the IRIs for each variable
+						Map<OWLEntity, IRI> entity2IRIMap = new HashMap<OWLEntity, IRI>();
+						entity2IRIMap.put(patternSubClass.asOWLClass(), subClass.getIRI());
+						for (OWLEntity entity : signature) {
+							String var = variablesMapping.get(entity);
+							Resource resource = qs.getResource(var);
+							entity2IRIMap.put(entity, IRI.create(resource.getURI()));
+						}
+						//instantiate the pattern
+						OWLObjectDuplicator duplicator = new OWLObjectDuplicator(entity2IRIMap, df);
+						OWLAxiom patternInstantiation = duplicator.duplicateObject(pattern);
+						int patternInstantiationCnt = qs.getLiteral("cnt").getInt();
+						//compute score
+						Score score;
+						try {
+							score = computeScore(subClassCnt, patternInstantiationCnt);
+							axioms2Score.put(patternInstantiation, score);
+							logger.info(patternInstantiation + "(" + format.format(score.getAccuracy()) + ")");
+						} catch (IllegalArgumentException e) {
+							//sometimes Virtuosos returns 'wrong' cnt values such that the success number as bigger than the total number of instances
+							e.printStackTrace();
+						}
+						
+//						//convert into EvaluatedAxiom such we can serialize it as RDF with accuracy value as annotation
+//						EvaluatedAxiom evaluatedAxiom = new EvaluatedAxiom(DLLearnerAxiomConvertVisitor.getDLLearnerAxiom(patternInstantiation), score);
+//						evaluatedAxioms.add(evaluatedAxiom);
+						
+					}
+					//wait some time to avoid flooding of endpoint
+					try {
+						Thread.sleep(waitingTime);
+					} catch (InterruptedException e) {
+						e.printStackTrace();
+					}
+//					if(i++ == 3) break;
+				}
+				save(axioms2Score);
+			}
+		}
+	}
+	
+	private void save(Map<OWLAxiom, Score> axioms2Score){
+		try {
+			Set<OWLAxiom> annotatedAxioms = new HashSet<OWLAxiom>();
+			for (Entry<OWLAxiom, Score> entry : axioms2Score.entrySet()) {
+				OWLAxiom axiom = entry.getKey();
+				Score score = entry.getValue();
+				if(score.getAccuracy() >= threshold){
+					annotatedAxioms.add(axiom.getAnnotatedAxiom(Collections.singleton(df.getOWLAnnotation(confidenceProperty, df.getOWLLiteral(score.getAccuracy())))));
+					
+				}
+			}
+			OWLOntologyManager man = OWLManager.createOWLOntologyManager();
+			OWLOntology ontology = man.createOntology(annotatedAxioms);
+			man.saveOntology(ontology, new TurtleOntologyFormat(), new FileOutputStream("pattern.ttl"));
+		} catch (OWLOntologyCreationException e) {
+			e.printStackTrace();
+		} catch (OWLOntologyStorageException e) {
+			e.printStackTrace();
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	private void save(Set<EvaluatedAxiom> evaluatedAxioms){
+		try {
+			Set<OWLAxiom> axioms = new HashSet<OWLAxiom>();
+			for (EvaluatedAxiom evaluatedAxiom : EvaluatedAxiom.getBestEvaluatedAxioms(evaluatedAxioms, threshold)) {
+				axioms.addAll(evaluatedAxiom.toRDF("http://dl-learner.org/pattern/").values().iterator().next());
+			}
+			OWLOntologyManager man = OWLManager.createOWLOntologyManager();
+			OWLOntology ontology = man.createOntology(axioms);
+			man.saveOntology(ontology, new TurtleOntologyFormat(), new FileOutputStream("pattern.ttl"));
+		} catch (OWLOntologyCreationException e) {
+			e.printStackTrace();
+		} catch (OWLOntologyStorageException e) {
+			e.printStackTrace();
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public List<OWLAxiom> getPatternsToEvaluate(){
+		List<OWLAxiom> axiomPatterns = new ArrayList<OWLAxiom>();
+		
+		Map<OWLAxiom, Pair<Integer, Integer>> topNAxiomPatterns = getTopNAxiomPatterns(AxiomTypeCategory.TBox, 10);
+		axiomPatterns.addAll(topNAxiomPatterns.keySet());
+		
+		return axiomPatterns;
+	}
+	
+	
+	private String asLatex(String title, Map<OWLAxiom, Pair<Integer, Integer>> topN){
+		String latexTable = "\\begin{table}\n";
+		latexTable += "\\begin{tabular}{lrr}\n";
+		latexTable += "\\toprule\n";
+		latexTable += "Pattern & Frequency & \\#Ontologies\\\\\\midrule\n";
+		
+		for (Entry<OWLAxiom, Pair<Integer, Integer>> entry : topN.entrySet()) {
+			OWLAxiom axiom = entry.getKey();
+			Integer frequency = entry.getValue().getKey();
+			Integer idf = entry.getValue().getValue();
+			
+			if(axiom != null){
+				String axiomColumn = axiomRenderer.render(axiom);
+				if(fancyLatex){
+					axiomColumn = "\\begin{lstlisting}[language=manchester]" + axiomColumn + "\\end{lstlisting}";
+				}
+				latexTable += axiomColumn + " & " + frequency + " & " + idf + "\\\\\n";
+			}
+		}
+		latexTable += "\\bottomrule\n\\end{tabular}\n";
+		latexTable += "\\caption{" + title + "}\n";
+		latexTable += "\\end{table}\n";
+		return latexTable;
+	}
+	
+	private Map<OWLAxiom, Pair<Integer, Integer>> getTopNAxiomPatterns(AxiomTypeCategory axiomType, int n){
+		Map<OWLAxiom, Pair<Integer, Integer>> topN = new LinkedHashMap<OWLAxiom, Pair<Integer, Integer>>();
+		PreparedStatement ps;
+		ResultSet rs;
+		try {
+			ps = conn.prepareStatement("SELECT pattern,SUM(occurrences),COUNT(ontology_id) FROM " +
+					"Ontology_Pattern OP, Pattern P, Ontology O WHERE " +
+					"(P.id=OP.pattern_id AND O.id=OP.ontology_id AND P.axiom_type=?) " +
+					"GROUP BY P.id ORDER BY SUM(`OP`.`occurrences`) DESC LIMIT ?");
+			ps.setString(1, axiomType.name());
+			ps.setInt(2, n);
+			rs = ps.executeQuery();
+			while(rs.next()){
+				topN.put(asOWLAxiom(rs.getString(1)), new Pair<Integer, Integer>(rs.getInt(2), rs.getInt(3)));
+			}
+		} catch(SQLException e){
+			e.printStackTrace();
+		}
+		return topN;
+	}
+	
+	protected com.hp.hpl.jena.query.ResultSet executeSelectQuery(Query query) {
+		com.hp.hpl.jena.query.ResultSet rs = null;
+		if(ks.isRemote()){
+			SparqlEndpoint endpoint = ((SparqlEndpointKS) ks).getEndpoint();
+			ExtractionDBCache cache = ks.getCache();
+			if(cache != null){
+				rs = SparqlQuery.convertJSONtoResultSet(cache.executeSelectQuery(endpoint, query.toString()));
+			} else {
+				QueryEngineHTTP queryExecution = new QueryEngineHTTP(endpoint.getURL().toString(),
+						query);
+				queryExecution.setDefaultGraphURIs(endpoint.getDefaultGraphURIs());
+				queryExecution.setNamedGraphURIs(endpoint.getNamedGraphURIs());
+				try {
+					rs = queryExecution.execSelect();
+					return rs;
+				} catch (QueryExceptionHTTP e) {
+					if(e.getCause() instanceof SocketTimeoutException){
+						logger.warn("Got timeout");
+					} else {
+						logger.error("Exception executing query", e);
+					}
+				}
+			}
+			
+		} else {
+			QueryExecution queryExecution = QueryExecutionFactory.create(query, ((LocalModelBasedSparqlEndpointKS)ks).getModel());
+			rs = queryExecution.execSelect();
+		}
+		return rs;
+	}
+	
+	protected com.hp.hpl.jena.query.ResultSet executeSelectQuery(Query query, boolean cached) {
+		com.hp.hpl.jena.query.ResultSet rs = null;
+		if(ks.isRemote()){
+			SparqlEndpoint endpoint = ((SparqlEndpointKS) ks).getEndpoint();
+			ExtractionDBCache cache = ks.getCache();
+			if(cache != null && cached){
+				rs = SparqlQuery.convertJSONtoResultSet(cache.executeSelectQuery(endpoint, query.toString()));
+			} else {
+				QueryEngineHTTP queryExecution = new QueryEngineHTTP(endpoint.getURL().toString(),
+						query);
+				queryExecution.setDefaultGraphURIs(endpoint.getDefaultGraphURIs());
+				queryExecution.setNamedGraphURIs(endpoint.getNamedGraphURIs());
+				try {
+					rs = queryExecution.execSelect();
+					return rs;
+				} catch (QueryExceptionHTTP e) {
+					if(e.getCause() instanceof SocketTimeoutException){
+						logger.warn("Got timeout");
+					} else {
+						logger.error("Exception executing query", e);
+					}
+				}
+			}
+			
+		} else {
+			QueryExecution queryExecution = QueryExecutionFactory.create(query, ((LocalModelBasedSparqlEndpointKS)ks).getModel());
+			rs = queryExecution.execSelect();
+		}
+		return rs;
+	}
+	
+	private Score computeScore(int total, int success){
+		double[] confidenceInterval = Heuristics.getConfidenceInterval95Wald(total, success);
+		
+		double accuracy = (confidenceInterval[0] + confidenceInterval[1]) / 2;
+	
+		double confidence = confidenceInterval[1] - confidenceInterval[0];
+		
+		return new AxiomScore(accuracy, confidence, total, success, total-success);
+	}
+	
+	private OWLAxiom asOWLAxiom(String functionalSyntaxAxiomString){
+		try {
+			StringDocumentSource s = new StringDocumentSource("Ontology(<http://www.pattern.org> " + functionalSyntaxAxiomString + ")");
+			OWLFunctionalSyntaxOWLParser p = new OWLFunctionalSyntaxOWLParser();
+			OWLOntology newOntology = OWLManager.createOWLOntologyManager().createOntology();
+			p.parse(s, newOntology);
+			if(!newOntology.getLogicalAxioms().isEmpty()){
+				return newOntology.getLogicalAxioms().iterator().next();
+			}
+		} catch (UnloadableImportException e) {
+			e.printStackTrace();
+		} catch (OWLOntologyCreationException e) {
+			e.printStackTrace();
+		} catch (OWLParserException e) {
+			System.err.println("Parsing failed for axiom " + functionalSyntaxAxiomString);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	public static void main(String[] args) throws Exception {
+		ToStringRenderer.getInstance().setRenderer(new DLSyntaxObjectRenderer());
+		new OWLAxiomPatternUsageEvaluation().run();
+	}
+	
+
+}

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