From 53ce0bea21c18061eabfd890f6ea6776fe4e1d08 Mon Sep 17 00:00:00 2001 From: Oszkar Semerath Date: Tue, 12 May 2020 02:38:04 +0200 Subject: advanced goal heuristics for missing containment and non-cont. edges --- .../ModelGenerationMethodProvider.xtend | 2 +- .../MultiplicityGoalConstraintCalculator.xtend | 19 ++++- .../patterns/PConstraintTransformer.xtend | 14 ++-- .../logic2viatra/patterns/PatternProvider.xtend | 25 +++++- .../rules/GoalConstraintProvider.xtend | 89 ++++++++++++++++++++-- .../dse/ModelGenerationCompositeObjective.xtend | 15 ++-- 6 files changed, 139 insertions(+), 25 deletions(-) (limited to 'Solvers/VIATRA-Solver') diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend index be11ed78..ca09ae00 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/ModelGenerationMethodProvider.xtend @@ -77,7 +77,7 @@ class ModelGenerationMethodProvider { objectRefinementRules = refinementRuleProvider.createObjectRefinementRules(logicProblem, emptySolution, queries,scopePropagator,nameNewElements,statistics) val relationRefinementRules = refinementRuleProvider.createRelationRefinementRules(queries,statistics) - val unfinishedMultiplicities = goalConstraintProvider.getUnfinishedMultiplicityQueries(queries) + val unfinishedMultiplicities = goalConstraintProvider.getUnfinishedMultiplicityQueries(logicProblem,queries) val unfinishedWF = queries.getUnfinishedWFQueries.values val invalidWF = queries.getInvalidWFQueries.values diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend index e05160d0..e1358fb6 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend @@ -10,23 +10,33 @@ class MultiplicityGoalConstraintCalculator { val String targetRelationName; val IQuerySpecification querySpecification; var ViatraQueryMatcher matcher; + val boolean containment + val int cost - public new(String targetRelationName, IQuerySpecification querySpecification) { + public new(String targetRelationName, IQuerySpecification querySpecification, boolean containment, int cost) { this.targetRelationName = targetRelationName this.querySpecification = querySpecification this.matcher = null + this.containment = containment + this.cost = cost } public new(MultiplicityGoalConstraintCalculator other) { this.targetRelationName = other.targetRelationName this.querySpecification = other.querySpecification this.matcher = null + this.containment = other.containment + this.cost = other.cost } def public getName() { targetRelationName } + def isContainment() { + return containment + } + def public init(Notifier notifier) { val engine = ViatraQueryEngine.on(new EMFScope(notifier)) matcher = querySpecification.getMatcher(engine) @@ -36,11 +46,14 @@ class MultiplicityGoalConstraintCalculator { var res = 0 val allMatches = this.matcher.allMatches for(match : allMatches) { - //println(targetRelationName+ " missing multiplicity: "+match.get(3)) + val missingMultiplicity = match.get(4) as Integer res += missingMultiplicity + if(missingMultiplicity!=0) { + println(targetRelationName+ " missing multiplicity: "+missingMultiplicity) + } } //println(targetRelationName+ " all missing multiplicities: "+res) - return res + return res*cost } } \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend index 4a8da38c..a4dcefbf 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend @@ -235,10 +235,10 @@ class PConstraintTransformer { «ENDFOR» check( «FOR variable: e.affectedVariables SEPARATOR " || "»!«variable.valueSetted»«ENDFOR» - «IF variable2Type.values.filter(RealTypeReference).empty» - || - («expressionGenerator.translateExpression(expression,e.affectedVariables.toInvertedMap[valueVariable],variable2Type)») - «ENDIF» +««« «IF variable2Type.values.filter(RealTypeReference).empty» +««« || +««« («expressionGenerator.translateExpression(expression,e.affectedVariables.toInvertedMap[valueVariable],variable2Type)») +««« «ENDIF» ); ''' } else { // Must or Current @@ -246,9 +246,9 @@ class PConstraintTransformer { «FOR variable: e.affectedVariables» PrimitiveElement.valueSet(«variable.canonizeName»,true); «hasValueExpression(variableMapping,variable,variable.valueVariable)» «ENDFOR» - «IF variable2Type.values.filter(RealTypeReference).empty» - check(«expressionGenerator.translateExpression(expression,e.affectedVariables.toInvertedMap[valueVariable],variable2Type)»); - «ENDIF» +««« «IF variable2Type.values.filter(RealTypeReference).empty» +««« check(«expressionGenerator.translateExpression(expression,e.affectedVariables.toInvertedMap[valueVariable],variable2Type)»); +««« «ENDIF» ''' } } diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend index 750107f6..cfea499b 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend @@ -27,7 +27,8 @@ import java.util.HashMap @Data class GeneratedPatterns { public Map>> invalidWFQueries public Map>> unfinishedWFQueries - public Map>> unfinishedMulticiplicityQueries + public Map>> unfinishedContainmentMulticiplicityQueries + public Map>> unfinishedNonContainmentMulticiplicityQueries public Map>> refineObjectQueries public Map>> refineTypeQueries public Map, IQuerySpecification>> refinerelationQueries @@ -86,8 +87,23 @@ class PatternProvider { invalidWFQueries = patternGenerator.invalidIndexer.getInvalidateByWfQueryNames(problem).mapValues[it.lookup(queries)] val Map>> unfinishedWFQueries = patternGenerator.unfinishedIndexer.getUnfinishedWFQueryNames(problem).mapValues[it.lookup(queries)] - val Map>> - unfinishedMultiplicityQueries = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(problem).mapValues[it.lookup(queries)] + + val unfinishedMultiplicities = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(problem) + val unfinishedContainmentMultiplicities = new HashMap + val unfinishedNonContainmentMultiplicities = new HashMap + for(entry : unfinishedMultiplicities.entrySet) { + val relation = entry.key + val value = entry.value.lookup(queries) + if(problem.containmentHierarchies.head.containmentRelations.contains(relation)) { + unfinishedContainmentMultiplicities.put(relation,value) + } else { + unfinishedNonContainmentMultiplicities.put(relation,value) + } + } +// val Map>> +// unfinishedMultiplicityQueries = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(problem).mapValues[it.lookup(queries)] +// + val Map>> refineObjectsQueries = patternGenerator.typeRefinementGenerator.getRefineObjectQueryNames(problem,emptySolution,typeAnalysisResult).mapValues[it.lookup(queries)] val Map>> @@ -101,7 +117,8 @@ class PatternProvider { return new GeneratedPatterns( invalidWFQueries, unfinishedWFQueries, - unfinishedMultiplicityQueries, + unfinishedContainmentMultiplicities, + unfinishedNonContainmentMultiplicities, refineObjectsQueries, refineTypeQueries, refineRelationQueries, diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend index e1be2742..87f7e339 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend @@ -1,18 +1,97 @@ package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules +import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type +import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.MultiplicityGoalConstraintCalculator import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns import java.util.ArrayList +import java.util.HashMap +import java.util.LinkedList +import java.util.List +import java.util.Map +import org.eclipse.viatra.query.runtime.api.IPatternMatch +import org.eclipse.viatra.query.runtime.api.IQuerySpecification +import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher + +import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* class GoalConstraintProvider { - def public getUnfinishedMultiplicityQueries(GeneratedPatterns patterns) { - val multiplicityQueries = patterns.unfinishedMulticiplicityQueries - val res = new ArrayList(multiplicityQueries.size) - for(multiplicityQuery : multiplicityQueries.entrySet) { + val calculateObjectCost = true + + def public getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns) { + val res = new ArrayList() + + res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true) + if(calculateObjectCost) { + val middingObjectCost = calculateMissingObjectCost(p) + res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false) + } else { + res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false) + } + return res + } + + def addAll(ArrayList res, Map>> queries, boolean containment) { + for(multiplicityQuery : queries.entrySet) { val targetRelationName = multiplicityQuery.key.name val query = multiplicityQuery.value - res += new MultiplicityGoalConstraintCalculator(targetRelationName,query); + res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,containment,1); + } + } + def addAll( + ArrayList res, + Map>> queries, + boolean containment, + Map cost + ) { + for(multiplicityQuery : queries.entrySet) { + val targetRelationName = multiplicityQuery.key.name + val query = multiplicityQuery.value + res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,containment,multiplicityQuery.key.lookup(cost)) + } + } + + def calculateMissingObjectCost(LogicProblem p) { + val containments = p.containmentHierarchies.head.containmentRelations + val containment2Lower = containments.toInvertedMap[containment | + val lower = p.annotations.filter(LowerMultiplicityAssertion).filter[it.relation === containment].head + if(lower !== null) { lower.lower } + else { 0 } + ] + val types = p.types + val Map>> type2NewCost = new HashMap + for(type:types) { + val allSupertypes = (#[type] + type.supertypes).toSet + val allOutgoingContainments = containments.filter[allSupertypes.contains((it.parameters.get(0) as ComplexTypeReference).referred)] + val list = new LinkedList + for(outgoingContainment : allOutgoingContainments) { + val value = containment2Lower.get(outgoingContainment) + if(value>0) { + list.add((outgoingContainment.parameters.get(1) as ComplexTypeReference).referred + -> value) + } + } + type2NewCost.put(type, list) + } + val res = new HashMap + for(containment : containments) { + val key = containment + val value = (containment.parameters.get(1) as ComplexTypeReference).referred.count(type2NewCost) + //println('''«key.name» --> «value» new''') + res.put(key,value) } return res } + + private def int count(Type t, Map>> containments) { + val list = containments.get(t) + var r = 1 + for(element : list) { + r += element.value * element.key.count(containments) + } + return r + } } \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend index 9e4792e0..e75cae41 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner/src/hu/bme/mit/inf/dslreasoner/viatrasolver/reasoner/dse/ModelGenerationCompositeObjective.xtend @@ -55,17 +55,22 @@ class ModelGenerationCompositeObjective implements IObjective{ //val unfinishedMultiplicitiesFitneses = unfinishedMultiplicityObjectives.map[x|x.getFitness(context)] val unfinishedWFsFitness = unfinishedWFObjective.getFitness(context) - - var multiplicity = 0.0 + var containmentMultiplicity = 0.0 + var nonContainmentMultiplicity = 0.0 for(multiplicityObjective : unfinishedMultiplicityObjectives) { - multiplicity+=multiplicityObjective.getFitness(context) + if(multiplicityObjective.containment) { + containmentMultiplicity+=multiplicityObjective.getFitness(context) + } else { + nonContainmentMultiplicity+=multiplicityObjective.getFitness(context) + } } var sum = 0.0 sum += scopeFitnes - sum +=multiplicity + sum += containmentMultiplicity + sum += Math.sqrt(nonContainmentMultiplicity) sum += unfinishedWFsFitness//*0.5 - println('''Sum=«sum»|Scope=«scopeFitnes»|Multiplicity=«multiplicity»|WFs=«unfinishedWFsFitness»''') + //println('''Sum=«sum»|Scope=«scopeFitnes»|ContainmentMultiplicity=«containmentMultiplicity»|NonContainmentMultiplicity=«nonContainmentMultiplicity»|WFs=«unfinishedWFsFitness»''') return sum } -- cgit v1.2.3-54-g00ecf