Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

535 fix includemetakis call in reasonerprocessor #538

Merged
merged 2 commits into from
Sep 11, 2024
Merged

535 fix includemetakis call in reasonerprocessor #538

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
30858de
MatchStrategy is now part of knowledge-engine module instead of reasoner
bnouwt Sep 10, 2024
fe3282f
Made the matching strategy available through the Java API.
bnouwt Sep 11, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
54 changes: 7 additions & 47 deletions reasoner/src/main/java/eu/knowledge/engine/reasoner/BaseRule.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -82,10 +82,6 @@ public static enum MatchFlag {
public static final EnumSet<MatchFlag> ALL_OPTS = EnumSet.allOf(MatchFlag.class);
}

public static enum MatchStrategy {
SUPREME_LEVEL, ULTRA_LEVEL, ADVANCED_LEVEL, NORMAL_LEVEL, ENTRY_LEVEL
}

public static class TrivialBindingSetHandler implements TransformBindingSetHandler {

private Set<TriplePattern> consequent;
Expand Down Expand Up @@ -169,7 +165,7 @@ public Set<TriplePattern> getConsequent() {
return this.consequent;
}

public Set<Match> consequentMatches(Set<TriplePattern> anAntecedent, MatchStrategy aMatchStrategy) {
public Set<Match> consequentMatches(Set<TriplePattern> anAntecedent, EnumSet<MatchFlag> aMatchConfig) {
if (!this.consequent.isEmpty()) {
Rule r = new Rule(anAntecedent, new SinkBindingSetHandler() {

Expand All @@ -179,19 +175,18 @@ public CompletableFuture<Void> handle(BindingSet aBindingSet) {
return null;
}
});
Map<BaseRule, Set<Match>> matches = getMatches(this, new HashSet<>(Arrays.asList(r)), false,
aMatchStrategy);
Map<BaseRule, Set<Match>> matches = getMatches(this, new HashSet<>(Arrays.asList(r)), false, aMatchConfig);

if (matches.containsKey(r))
return matches.get(r);
}
return new HashSet<>();
}

public Set<Match> antecedentMatches(Set<TriplePattern> aConsequent, MatchStrategy aMatchStrategy) {
public Set<Match> antecedentMatches(Set<TriplePattern> aConsequent, EnumSet<MatchFlag> aMatchConfig) {
if (!this.antecedent.isEmpty()) {
Rule r = new Rule(new HashSet<>(), aConsequent);
Map<BaseRule, Set<Match>> matches = getMatches(this, new HashSet<>(Arrays.asList(r)), true, aMatchStrategy);
Map<BaseRule, Set<Match>> matches = getMatches(this, new HashSet<>(Arrays.asList(r)), true, aMatchConfig);
if (matches.containsKey(r))
return matches.get(r);
}
Expand Down Expand Up @@ -382,9 +377,7 @@ public static Map<TriplePattern, Set<CombiMatch>> getMatchesPerTriplePerRule(Set
* @return A set of matches that all contribute to some full matche.
*/
public static Map<BaseRule, Set<Match>> getMatches(BaseRule aTargetRule, Set<BaseRule> someCandidateRules,
boolean antecedentOfTarget, MatchStrategy aStrategy) {

EnumSet<MatchFlag> config = fromStrategyToConfig(aStrategy, antecedentOfTarget);
boolean antecedentOfTarget, EnumSet<MatchFlag> config) {

Set<TriplePattern> targetGP = antecedentOfTarget ? aTargetRule.getAntecedent() : aTargetRule.getConsequent();

Expand Down Expand Up @@ -417,8 +410,8 @@ public static Map<BaseRule, Set<Match>> getMatches(BaseRule aTargetRule, Set<Bas

if (triplePatternMatchesIter.hasNext()) {
Set<CombiMatch> value = triplePatternMatchesIter.next().getValue();
LOG.trace("{}/{} ({}): biggest: {}, smaller: {}", 1, combiMatchesPerTriple.size(), value.size(),
biggestMatches.size(), smallerMatches.size());
LOG.trace("{}/{} ({}): biggest: {}, smaller: {} ({})", 1, combiMatchesPerTriple.size(), value.size(),
biggestMatches.size(), smallerMatches.size(), config);
biggestMatches.addAll(value);
}

Expand Down Expand Up @@ -545,39 +538,6 @@ private static boolean isSubCombiMatch(CombiMatch aSmallerMatch, List<CombiMatch
return false;
}

private static EnumSet<MatchFlag> fromStrategyToConfig(MatchStrategy aStrategy, boolean antecedentOfTarget) {
EnumSet<MatchFlag> config;
switch (aStrategy) {
case ENTRY_LEVEL:
config = EnumSet.of(MatchFlag.FULLY_COVERED, MatchFlag.ONE_TO_ONE, MatchFlag.ONLY_BIGGEST,
MatchFlag.SINGLE_RULE);
break;
case NORMAL_LEVEL:
config = EnumSet.of(MatchFlag.ONE_TO_ONE, MatchFlag.ONLY_BIGGEST);

// disable fully covered when matching consequents.
if (antecedentOfTarget)
config.add(MatchFlag.FULLY_COVERED);
break;
case ADVANCED_LEVEL:
config = EnumSet.of(MatchFlag.ONLY_BIGGEST);

// disable fully covered when matching consequents.
if (antecedentOfTarget)
config.add(MatchFlag.FULLY_COVERED);
break;
case ULTRA_LEVEL:
config = EnumSet.of(MatchFlag.ONLY_BIGGEST);
break;
case SUPREME_LEVEL:
config = EnumSet.noneOf(MatchFlag.class);
break;
default:
config = EnumSet.noneOf(MatchFlag.class);
}
return config;
}

private static void printCombiMatchesPerTriple(Map<TriplePattern, Set<CombiMatch>> combiMatchesPerTriple) {
StringBuilder sb = new StringBuilder();

Expand Down
25 changes: 13 additions & 12 deletions reasoner/src/main/java/eu/knowledge/engine/reasoner/ReasonerPlan.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,7 @@

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
Expand All @@ -11,7 +12,7 @@
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import eu.knowledge.engine.reasoner.BaseRule.MatchStrategy;
import eu.knowledge.engine.reasoner.BaseRule.MatchFlag;
import eu.knowledge.engine.reasoner.api.Binding;
import eu.knowledge.engine.reasoner.api.BindingSet;
import eu.knowledge.engine.reasoner.api.TriplePattern;
Expand All @@ -38,7 +39,7 @@ public class ReasonerPlan {
private final ProactiveRule start;
private final Map<BaseRule, RuleNode> ruleToRuleNode;
private boolean done;
private MatchStrategy strategy = MatchStrategy.ULTRA_LEVEL;
private EnumSet<MatchFlag> matchConfig = EnumSet.noneOf(MatchFlag.class);
private boolean useTaskBoard = true;

public ReasonerPlan(RuleStore aStore, ProactiveRule aStartRule) {
Expand All @@ -48,11 +49,11 @@ public ReasonerPlan(RuleStore aStore, ProactiveRule aStartRule) {
createOrGetReasonerNode(this.start, null);
}

public ReasonerPlan(RuleStore aStore, ProactiveRule aStartRule, MatchStrategy aStrategy) {
public ReasonerPlan(RuleStore aStore, ProactiveRule aStartRule, EnumSet<MatchFlag> aConfig) {
this.store = aStore;
this.start = aStartRule;
this.ruleToRuleNode = new HashMap<>();
this.strategy = aStrategy;
this.matchConfig = aConfig;
createOrGetReasonerNode(this.start, null);
}

Expand Down Expand Up @@ -231,7 +232,7 @@ private RuleNode createOrGetReasonerNode(BaseRule aRule, BaseRule aParent) {
// for now we only are interested in antecedent neighbors.
// TODO for looping we DO want to consider consequent neighbors as well.

this.store.getAntecedentNeighbors(aRule, this.strategy).forEach((rule, matches) -> {
this.store.getAntecedentNeighbors(aRule, this.matchConfig).forEach((rule, matches) -> {
if (!(rule instanceof ProactiveRule)) {
assert reasonerNode instanceof AntSide;
var newNode = createOrGetReasonerNode(rule, aRule);
Expand All @@ -247,7 +248,7 @@ private RuleNode createOrGetReasonerNode(BaseRule aRule, BaseRule aParent) {
});
} else {
// interested in both consequent and antecedent neighbors
this.store.getConsequentNeighbors(aRule, this.strategy).forEach((rule, matches) -> {
this.store.getConsequentNeighbors(aRule, this.matchConfig).forEach((rule, matches) -> {
if (!(rule instanceof ProactiveRule)) {
assert reasonerNode instanceof ConsSide;
var newNode = createOrGetReasonerNode(rule, aRule);
Expand All @@ -266,13 +267,13 @@ private RuleNode createOrGetReasonerNode(BaseRule aRule, BaseRule aParent) {
// determine whether our parent matches us partially
boolean ourAntecedentFullyMatchesParentConsequent = false;

if (aParent != null && this.store.getAntecedentNeighbors(aRule, this.strategy).containsKey(aParent)) {
if (aParent != null && this.store.getAntecedentNeighbors(aRule, this.matchConfig).containsKey(aParent)) {
ourAntecedentFullyMatchesParentConsequent = antecedentFullyMatchesConsequent(aRule, aParent,
this.store.getAntecedentNeighbors(aRule, this.strategy).get(aParent), this.strategy);
this.store.getAntecedentNeighbors(aRule, this.matchConfig).get(aParent));
}

if (!ourAntecedentFullyMatchesParentConsequent) {
this.store.getAntecedentNeighbors(aRule, this.strategy).forEach((rule, matches) -> {
this.store.getAntecedentNeighbors(aRule, this.matchConfig).forEach((rule, matches) -> {
if (!(rule instanceof ProactiveRule)) {
assert reasonerNode instanceof AntSide;
var newNode = createOrGetReasonerNode(rule, aRule);
Expand Down Expand Up @@ -317,7 +318,7 @@ private void scheduleOrDoTask(RuleNode current, TaskBoard taskBoard) {
* @return
*/
private boolean antecedentFullyMatchesConsequent(BaseRule antecedentRule, BaseRule consequentRule,
Set<Match> someMatches, MatchStrategy aMatchStrategy) {
Set<Match> someMatches) {

var antecedent = antecedentRule.getAntecedent();
var consequent = consequentRule.getConsequent();
Expand Down Expand Up @@ -348,8 +349,8 @@ private boolean antecedentFullyMatchesConsequent(BaseRule antecedentRule, BaseRu
return false;
}

public MatchStrategy getMatchStrategy() {
return this.strategy;
public EnumSet<MatchFlag> getMatchConfig() {
return this.matchConfig;
}

public RuleStore getStore() {
Expand Down
112 changes: 14 additions & 98 deletions reasoner/src/main/java/eu/knowledge/engine/reasoner/rulestore/MatchNode.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,11 +1,12 @@
package eu.knowledge.engine.reasoner.rulestore;

import java.util.EnumSet;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import eu.knowledge.engine.reasoner.BaseRule;
import eu.knowledge.engine.reasoner.BaseRule.MatchStrategy;
import eu.knowledge.engine.reasoner.BaseRule.MatchFlag;
import eu.knowledge.engine.reasoner.Match;

/**
Expand All @@ -31,128 +32,47 @@ public class MatchNode {
* All other rules in the {@link MatchNode#store} whose consequents match this
* rule's antecedent according to the {@link MatchStrategy#NORMAL_LEVEL}
*/
private Map<BaseRule, Set<Match>> antecedentNeighborsNormal;

/**
* All other rules in the {@link MatchNode#store} whose consequents match this
* rule's antecedent according to the {@link MatchStrategy#ADVANCED_LEVEL}
*/
private Map<BaseRule, Set<Match>> antecedentNeighborsAdvanced;

/**
* All other rules in the {@link MatchNode#store} whose consequents match this
* rule's antecedent according to the {@link MatchStrategy#ULTRA_LEVEL}
*/
private Map<BaseRule, Set<Match>> antecedentNeighborsUltra;
private Map<BaseRule, Set<Match>> antecedentNeighbors;

/**
* All other rules in the {@link MatchNode#store} whose antecedents match this
* rule's consequent according to the {@link MatchStrategy#NORMAL_LEVEL}
*/
private Map<BaseRule, Set<Match>> consequentNeighborsNormal;

/**
* All other rules in the {@link MatchNode#store} whose antecedents match this
* rule's consequent according to the {@link MatchStrategy#ADVANCED_LEVEL}
*/
private Map<BaseRule, Set<Match>> consequentNeighborsAdvanced;

/**
* All other rules in the {@link MatchNode#store} whose antecedents match this
* rule's consequent according to the {@link MatchStrategy#ULTRA_LEVEL}
*/
private Map<BaseRule, Set<Match>> consequentNeighborsUltra;
private Map<BaseRule, Set<Match>> consequentNeighbors;

public MatchNode(BaseRule aRule) {
this.rule = aRule;
this.antecedentNeighborsNormal = new HashMap<>();
this.antecedentNeighborsAdvanced = new HashMap<>();
this.antecedentNeighborsUltra = new HashMap<>();
this.consequentNeighborsNormal = new HashMap<>();
this.consequentNeighborsAdvanced = new HashMap<>();
this.consequentNeighborsUltra = new HashMap<>();
this.antecedentNeighbors = new HashMap<>();
this.consequentNeighbors = new HashMap<>();

}

public BaseRule getRule() {
return this.rule;
}

public void setConsequentNeighbor(BaseRule aRule, Set<Match> someMatches) {
this.setConsequentNeighbor(aRule, someMatches, MatchStrategy.ULTRA_LEVEL);
}

public void setAntecedentNeighbor(BaseRule aRule, Set<Match> someMatches) {
this.setAntecedentNeighbor(aRule, someMatches, MatchStrategy.ULTRA_LEVEL);
}

public void setConsequentNeighbor(BaseRule aRule, Set<Match> someMatches, MatchStrategy aStrategy) {
Map<BaseRule, Set<Match>> neighbors;
if (aStrategy.equals(MatchStrategy.NORMAL_LEVEL) || aStrategy.equals(MatchStrategy.ENTRY_LEVEL)) {
neighbors = this.consequentNeighborsNormal;
} else if (aStrategy.equals(MatchStrategy.ADVANCED_LEVEL)) {
neighbors = this.consequentNeighborsAdvanced;
} else if (aStrategy.equals(MatchStrategy.ULTRA_LEVEL)) {
neighbors = this.consequentNeighborsUltra;
} else {
assert false;
neighbors = new HashMap<>();
}
Map<BaseRule, Set<Match>> neighbors = this.consequentNeighbors;

if (!neighbors.containsKey(aRule)) {
neighbors.put(aRule, someMatches);
}
}

public void setAntecedentNeighbor(BaseRule aRule, Set<Match> someMatches, MatchStrategy aStrategy) {
Map<BaseRule, Set<Match>> neighbors;
if (aStrategy.equals(MatchStrategy.NORMAL_LEVEL) || aStrategy.equals(MatchStrategy.ENTRY_LEVEL)) {
neighbors = this.antecedentNeighborsNormal;
} else if (aStrategy.equals(MatchStrategy.ADVANCED_LEVEL)) {
neighbors = this.antecedentNeighborsAdvanced;
} else if (aStrategy.equals(MatchStrategy.ULTRA_LEVEL)) {
neighbors = this.antecedentNeighborsUltra;
} else {
assert false;
neighbors = new HashMap<>();
}
public void setAntecedentNeighbor(BaseRule aRule, Set<Match> someMatches) {
Map<BaseRule, Set<Match>> neighbors = this.antecedentNeighbors;

if (!neighbors.containsKey(aRule)) {
neighbors.put(aRule, someMatches);
}
}

public Map<BaseRule, Set<Match>> getConsequentNeighbors() {
return this.getConsequentNeighbors(MatchStrategy.ULTRA_LEVEL);
return this.consequentNeighbors;
}

public Map<BaseRule, Set<Match>> getAntecedentNeighbors() {
return this.getAntecedentNeighbors(MatchStrategy.ULTRA_LEVEL);
}

public Map<BaseRule, Set<Match>> getConsequentNeighbors(MatchStrategy aStrategy) {
if (aStrategy.equals(MatchStrategy.NORMAL_LEVEL)) {
return this.consequentNeighborsNormal;
} else if (aStrategy.equals(MatchStrategy.ADVANCED_LEVEL)) {
return this.consequentNeighborsAdvanced;
} else if (aStrategy.equals(MatchStrategy.ULTRA_LEVEL)) {
return this.consequentNeighborsUltra;
} else {
assert false;
return null;
}
}

public Map<BaseRule, Set<Match>> getAntecedentNeighbors(MatchStrategy aStrategy) {
if (aStrategy.equals(MatchStrategy.NORMAL_LEVEL)) {
return this.antecedentNeighborsNormal;
} else if (aStrategy.equals(MatchStrategy.ADVANCED_LEVEL)) {
return this.antecedentNeighborsAdvanced;
} else if (aStrategy.equals(MatchStrategy.ULTRA_LEVEL)) {
return this.antecedentNeighborsUltra;
} else {
assert false;
return null;
}
return this.antecedentNeighbors;
}

/**
Expand All @@ -163,12 +83,8 @@ public RuleStore getStore() {
}

public void reset() {
this.antecedentNeighborsNormal.clear();
this.antecedentNeighborsAdvanced.clear();
this.antecedentNeighborsUltra.clear();
this.consequentNeighborsNormal.clear();
this.consequentNeighborsAdvanced.clear();
this.consequentNeighborsUltra.clear();
this.antecedentNeighbors.clear();
this.consequentNeighbors.clear();

}
}
Loading
Loading