Cleanup of owl:hasValue precomputation

Author: LorenzBuehmann

components-core/src/main/java/org/dllearner/refinementoperators/RhoDRDown.java

@@ -80,9 +80,6 @@ public class RhoDRDown extends RefinementOperatorAdapter implements Component, C
 	@ConfigOption(description = "the reasoner to use")
 	private AbstractReasonerComponent reasoner;
 
-	//@ConfigOption(description = "the learning algorithm")
-	//private
-
 	// hierarchies
 	@NoConfigOption
 	private ClassHierarchy classHierarchy;
@@ -163,14 +160,10 @@ public class RhoDRDown extends RefinementOperatorAdapter implements Component, C
 	@ConfigOption(defaultValue = "3", description = "minimum number an individual or literal has to be seen in the " +
 			"knowledge base before considering it for inclusion in concepts")
 	private int frequencyThreshold = CommonConfigOptions.valueFrequencyThresholdDefault;
-	private Map<OWLObjectPropertyExpression, Map<OWLIndividual, Integer>> valueFrequency = new HashMap<>();
 	// data structure with identified frequent values
 	private Map<OWLObjectPropertyExpression, Set<OWLIndividual>> frequentValues = new HashMap<>();
 	// frequent data values
 	private Map<OWLDataProperty, Set<OWLLiteral>> frequentDataValues = new HashMap<>();
-	private Map<OWLDataProperty, Map<OWLLiteral, Integer>> dataValueFrequency = new HashMap<>();
-	@ConfigOption(description = "whether to use hasValue on frequently occuring strings", defaultValue = "false")
-	private boolean useDataHasValueConstructor = false;
 
 	// statistics
 	public long mComputationTimeNs = 0;
@@ -192,6 +185,9 @@ public class RhoDRDown extends RefinementOperatorAdapter implements Component, C
 	@ConfigOption(description="support of has value constructor (owl:hasValue), e.g. \u2203 r.{a} ", defaultValue="false")
 	private boolean useHasValueConstructor = false;
 
+	@ConfigOption(description = "support of has value constructor (owl:hasValue), e.g. \u2203 r.{20} ", defaultValue = "false")
+	private boolean useDataHasValueConstructor = false;
+
 	@ConfigOption(description="support of qualified cardinality restrictions (owl:minCardinality, owl:maxCardinality, owl:exactCardinality), e.g. \u2265 3 r.C ", defaultValue="true")
 	private boolean useCardinalityRestrictions = true;
 
@@ -245,31 +241,45 @@ public class RhoDRDown extends RefinementOperatorAdapter implements Component, C
 
 	public RhoDRDown() {}
 
+	/**
+	 * Copy constructor
+	 */
 	public RhoDRDown(RhoDRDown op) {
 		setApplyAllFilter(op.applyAllFilter);
 		setCardinalityLimit(op.cardinalityLimit);
 		setClassHierarchy(op.classHierarchy);
+		setObjectPropertyHierarchy(op.objectPropertyHierarchy);
 		setDataPropertyHierarchy(op.dataPropertyHierarchy);
 		setDropDisjuncts(op.dropDisjuncts);
-		setFrequencyThreshold(op.frequencyThreshold);
 		setInstanceBasedDisjoints(op.instanceBasedDisjoints);
-		setObjectPropertyHierarchy(op.objectPropertyHierarchy);
 		setReasoner(op.reasoner);
 		setStartClass(op.startClass);
-		setSubHierarchy(op.classHierarchy);
 		setUseAllConstructor(op.useAllConstructor);
-		setUseBooleanDatatypes(op.useBooleanDatatypes);
 		setUseCardinalityRestrictions(op.useCardinalityRestrictions);
-		setUseDataHasValueConstructor(op.useDataHasValueConstructor);
 		setUseExistsConstructor(op.useExistsConstructor);
-		setUseHasValueConstructor(op.useHasValueConstructor);
 		setUseNegation(op.useNegation);
+		setUseHasValueConstructor(op.useHasValueConstructor);
 		setUseObjectValueNegation(op.useObjectValueNegation);
+		setFrequencyThreshold(op.frequencyThreshold);
+		setUseDataHasValueConstructor(op.useDataHasValueConstructor);
+		setUseBooleanDatatypes(op.useBooleanDatatypes);
 		setUseStringDatatypes(op.useStringDatatypes);
 		setUseNumericDatatypes(op.useNumericDatatypes);
+		setUseTimeDatatypes(op.useTimeDatatypes);
 		initialized = false;
 	}
 
+	private <T> Set<T> frequentObjects(Collection<? extends Collection<T>> c, int frequencyThreshold) {
+		final int t = frequencyThreshold;
+		return c.stream()
+				.flatMap(Collection::stream)
+				.collect(Collectors.collectingAndThen(Collectors.groupingBy(Function.identity(), Collectors.counting()),
+						map -> {
+							map.values().removeIf(v -> v < t);
+							return map.keySet();
+						}));
+	}
+
 	@Override
     public void init() throws ComponentInitException {
 		/*
@@ -291,99 +301,39 @@ public void init() throws ComponentInitException {
 		opRanges = reasoner.getObjectPropertyRanges();
 		dpDomains = reasoner.getDataPropertyDomains();
 
+		// r. some {ind}
 		if (useHasValueConstructor) {
 			for (OWLObjectProperty op : objectPropertyHierarchy.getEntities()) {
-				// sets ordered by corresponding individual (which we ignore)
-				Map<OWLIndividual, SortedSet<OWLIndividual>> propertyMembers = reasoner.getPropertyMembers(op);
-
-				Collection<SortedSet<OWLIndividual>> fillerSets = propertyMembers.values();
-
-				// compute frequency of individuals used as object
-				Map<OWLIndividual, Integer> ind2Frequency = fillerSets.stream()
-						.flatMap(Collection::stream)
-						.collect(Collectors.groupingBy(Function.identity(), TreeMap::new, summingInt(s -> 1))); // (ind -> freqency)
 
-				// keep track of this
-				valueFrequency.put(op, ind2Frequency);
+				Map<OWLIndividual, SortedSet<OWLIndividual>> propertyMembers = reasoner.getPropertyMembers(op);
 
-				// keep only individuals with frequency > threshold
-				Set<OWLIndividual> frequentInds = ind2Frequency.entrySet().stream()
-						.filter(e -> e.getValue() >= frequencyThreshold) // frequency >= threshold
-						.map(Map.Entry::getKey)
-						.collect(Collectors.toCollection(TreeSet::new));
+				// compute the frequency of all individuals used as object and filter by threshold
+				Set<OWLIndividual> frequentInds = frequentObjects(propertyMembers.values(), frequencyThreshold);
 				frequentValues.put(op, frequentInds);
 
+				// inv(r). some {ind}
 				if(useInverse) {
-					Map<OWLIndividual, Integer> opMap = new TreeMap<>();
-					valueFrequency.put(op.getInverseProperty(), opMap);
-
-					frequentInds = new TreeSet<>();
-
-					for (Entry<OWLIndividual, SortedSet<OWLIndividual>> entry : propertyMembers
-							.entrySet()) {
-						OWLIndividual subject = entry.getKey();
-						SortedSet<OWLIndividual> values = entry.getValue();
-
-						opMap.put(subject, values.size());
-
-						if (values.size() >= frequencyThreshold) {
-							frequentInds.add(subject);
-						}
-					}
+					// it's a bit easier for inverse properties since we have a mapping from each individual to
+					// all related individuals, thus, the freuqncy of each individual as subject is just the number
+					// of objects
+					frequentInds = propertyMembers.entrySet().stream().collect(Collectors.collectingAndThen(
+							Collectors.toMap(Entry::getKey, e -> e.getValue().size()), map -> {
+								map.values().removeIf(v -> v < frequencyThreshold);
+								return map.keySet();
+					}));
 					frequentValues.put(op.getInverseProperty(), frequentInds);
 				}
 			}
 		}
 
+		// r. some {lit}
 		if(useDataHasValueConstructor) {
 			for(OWLDataProperty dp : dataPropertyHierarchy.getEntities()) {
-				Map<OWLLiteral, Integer> dpMap = new TreeMap<>();
-				dataValueFrequency.put(dp, dpMap);
-
-//				long s1 = System.currentTimeMillis();
-//				ConcurrentMap<OWLLiteral, Integer> lit2frequency = reasoner.getDatatypeMembers(dp).values()
-//						.parallelStream()
-//						.map(set -> set.stream().collect(Collectors.toList()))
-//						.flatMap(list -> list.stream())
-//						.collect(Collectors.toConcurrentMap(
-//								Function.identity(), lit -> 1, Integer::sum));
-//				long s2 = System.currentTimeMillis();
-//				System.out.println(s2 - s1);
-
-				// sets ordered by corresponding individual (which we ignore)
-//				s1 = System.currentTimeMillis();
-				Collection<SortedSet<OWLLiteral>> fillerSets = reasoner.getDatatypeMembers(dp).values();
-				for(SortedSet<OWLLiteral> fillerSet : fillerSets) {
-					for(OWLLiteral lit : fillerSet) {
-						Integer frequency = dpMap.get(lit);
-
-						if(frequency != null) {
-							dpMap.put(lit, frequency+1);
-						} else {
-							dpMap.put(lit, 1);
-						}
-					}
-				}
-//				s2 = System.currentTimeMillis();
-//				System.out.println(s2 - s1);
-
-				// keep only frequent patterns
-				Set<OWLLiteral> frequentInds = new TreeSet<>();
-				for(OWLLiteral i : dpMap.keySet()) {
-					if(dpMap.get(i) >= frequencyThreshold) {
-						logger.trace("adding value "+i+", because "+dpMap.get(i) +">="+frequencyThreshold);
-						frequentInds.add(i);
-					}
-				}
-				frequentDataValues.put(dp, frequentInds);
+				Set<OWLLiteral> frequentLiterals = frequentObjects(reasoner.getDatatypeMembers(dp).values(), frequencyThreshold);
+				frequentDataValues.put(dp, frequentLiterals);
 			}
 		}
 
-		// we do not need the temporary set anymore and let the
-		// garbage collector take care of it
-		valueFrequency = null;
-		dataValueFrequency.clear();// = null;
-
 		// compute splits for numeric data properties
 		if(useNumericDatatypes) {
 			if(reasoner instanceof SPARQLReasoner
@@ -1120,11 +1070,7 @@ private void computeTopRefinements(int maxLength, OWLClassExpression domain) {
 						// TODO: similar filtering can be done for boolean datatype
 						// properties
 						if(applyExistsFilter) {
-							Iterator<OWLObjectUnionOf> it = baseSet.iterator();
-							while(it.hasNext()) {
-								if(MathOperations.containsDoubleObjectSomeRestriction(it.next()))
-									it.remove();
-							}
+							baseSet.removeIf(MathOperations::containsDoubleObjectSomeRestriction);
 						}
 
 						// add computed refinements