add realistic solver

4 files changed, 404 insertions, 0 deletions

diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Domain.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Domain.xtend
new file mode 100644
index 00000000..c8fd435b
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Domain.xtend
@@ -0,0 +1,7 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app
+
+enum Domain{
+        Yakindumm,
+        Ecore,
+        Github
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Main.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Main.xtend
new file mode 100644
index 00000000..dfde6593
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/Main.xtend
@@ -0,0 +1,96 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.EMFGraph
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io.CsvFileWriter
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io.GraphReader
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.validation.ViolationCheck
+import hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.impl.YakindummPackageImpl
+import java.io.File
+import java.util.ArrayList
+import org.eclipse.emf.ecore.EPackage
+import org.eclipse.emf.ecore.EcorePackage
+import org.eclipse.viatra.query.runtime.rete.matcher.ReteEngine
+import org.eclipse.emf.ecore.impl.EcorePackageImpl
+import org.eclipse.emf.ecore.EReference
+
+//import yakindumm2.impl.Yakindumm2PackageImpl
+
+class Main {
+        var static Domain d = Domain.Yakindumm;
+        val static String suffix = '.xmi'
+        val static String OUTPUT_FOLDER = "Inputs/measurement2/yakindu/Alloy/";
+        val static String INPUT_FOLDER = "outputs/measurement2/yakindu/Alloy/";
+        val static int NUM_RUNS = 1;
+        
+        static class RWInformation{
+                public var String inputFolder;
+                public var String outputFolder;
+                public var int numRuns;
+                
+                new(String inputFolder, String outputFolder, int numRuns){
+                        this.inputFolder = inputFolder;
+                        this.outputFolder = outputFolder;
+                        this.numRuns = numRuns;
+                }
+        }
+        
+        def static void main(String[] args){
+                //init model
+                var EPackage metamodel;
+                //init viatra engine for the violation checker
+                ReteEngine.getClass();
+                
+                if(d == Domain.Yakindumm){
+                        YakindummPackageImpl.eINSTANCE.eClass;
+                        metamodel = YakindummPackageImpl.eINSTANCE;
+                }else if (d == Domain.Ecore){
+                        EcorePackage.eINSTANCE.eClass;
+                        metamodel = EcorePackageImpl.eINSTANCE;
+                }else if (d == Domain.Github){
+                        //TODO: Initialize Github Package
+                }
+                
+                                                                                
+                println("Start Reading Models...");
+                var reader = new GraphReader(metamodel, suffix);
+
+                val models = new RWInformation(OUTPUT_FOLDER, INPUT_FOLDER, NUM_RUNS);
+                calculateAllModels(models.inputFolder, models.outputFolder,models.numRuns, reader);     
+                println("finished");
+        }
+        
+        static def calculateAllModels(String inputFolder, String outputFolder, int numRuns, GraphReader reader){
+                (new File(outputFolder)).mkdir();
+                for(var i = 1; i <= numRuns; i++){
+                        val models = new ArrayList<EMFGraph>();
+                        models.addAll(reader.readModels(inputFolder + "run" + i));
+                        for(model : models){
+                                calculateAndOutputMetrics(model, YakindummPackageImpl.eNAME, outputFolder+model.name+"_run_"+i+".csv");
+                        }
+                }
+                println("output results Ended for: " + outputFolder);
+                
+                
+        }
+        
+        static def calculateAndOutputMetrics(EMFGraph model, String metaModel, String fileName){
+                //println("evaluating for " + model.name);              
+                model.metaModel = metaModel;
+                
+                //remove eGenericType for Ecore domain
+                if(d == Domain.Ecore){
+                        var refsToRemove = EcorePackageImpl.eINSTANCE.eAllContents.filter(EReference).filter[
+                                it.name.equals('eGenericType') || it.name.equals('eGenericSuperTypes') || it.name.equals('eFactoryInstance')||
+                                it.name.equals('eGenericExceptions') || it.name.equals('references') || it.name.equals('contents');
+                        ];
+                        refsToRemove.forEach[model.removeReference(it)];
+                }
+                
+                var outputs = model.evaluateAllMetrics();
+                var violations = ViolationCheck.calculateViolationCounts(model.root, d);
+                println(violations);
+                var violationsOutput = newArrayList('violations', violations+'');
+                outputs.add(violationsOutput);
+                CsvFileWriter.write(outputs, fileName);
+        }
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/PartialInterpretationMetric.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/PartialInterpretationMetric.xtend
new file mode 100644
index 00000000..5e62b586
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/PartialInterpretationMetric.xtend
@@ -0,0 +1,85 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.JSDistance
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.KSDistance
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.PartialInterpretationGraph
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io.CsvFileWriter
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MultiplexParticipationCoefficientMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.NodeActivityMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.OutDegreeMetric
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import java.io.File
+import java.io.FileNotFoundException
+import java.io.PrintWriter
+import java.util.ArrayList
+import java.util.List
+import org.eclipse.emf.ecore.util.EcoreUtil
+import org.eclipse.viatra.dse.api.Solution
+
+class PartialInterpretationMetric {
+        var static KSDistance ks;
+        var static JSDistance js;
+        
+        def static void initPaths(){
+                new File("debug/metric/").mkdir();
+                new File("debug/metric/trajectories/").mkdir();
+        }
+        
+        // calculate the metrics for a state
+        def static void calculateMetric(PartialInterpretation partial, String path, String currentStateId, Integer counter){
+                val metrics = new ArrayList<Metric>();
+                metrics.add(new OutDegreeMetric());
+                metrics.add(new NodeActivityMetric());
+                metrics.add(new MultiplexParticipationCoefficientMetric());
+                
+                //make dir since the folder can be none existing
+                new File(path).mkdir();
+                val filename = path + "/state_"+currentStateId+"-"+counter+".csv";
+                val metricCalculator = new PartialInterpretationGraph(partial, metrics, currentStateId);
+                
+                CsvFileWriter.write(metricCalculator.evaluateAllMetrics(), filename);
+        }
+        
+        def static void outputTrajectories(PartialInterpretation empty, List<Solution>  solutions){     
+                for(solution : solutions){
+                        
+                        //need to copy the empty solution because the transition directly worked on the graph
+                        val emptySolutionCopy = EcoreUtil.copy(empty)
+                        val trajectory = solution.shortestTrajectory;
+                        trajectory.model = emptySolutionCopy
+                        
+                        // state codes that will record the trajectory
+                        val stateCodes = newArrayList()
+                        var counter = 0
+
+                        //transform and record the state codes for each state
+                        while(trajectory.doNextTransformation){
+                                //println(trajectory.stateCoder.createStateCode)
+                                val stateId = trajectory.stateCoder.createStateCode.toString
+                                val interpretation = trajectory.getModel();
+                                println(stateId)
+                                //calculate metrics of current state
+                                calculateMetric(interpretation as PartialInterpretation, "debug/metric/output", stateId, counter)
+                                stateCodes.add(stateId)
+                                counter++
+                        }
+                        
+                        
+                        //output the trajectory
+                        try{
+                                new File("debug/metric/trajectories/").mkdir();
+                                val path = "debug/metric/trajectories/trajectory"+trajectory.stateCoder.createStateCode.toString+".csv"
+                                val PrintWriter writer = new PrintWriter(new File(path))
+                                val output = new StringBuilder
+                                for(stateCode : stateCodes){
+                                        output.append(stateCode+'\n')
+                                }
+                                writer.write(output.toString())
+                                writer.close()
+                        }catch(FileNotFoundException e) {
+                                e.printStackTrace()
+                        }
+                }                       
+        }
+}
\ No newline at end of file
diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/PartialInterpretationMetricDistance.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/PartialInterpretationMetricDistance.xtend
new file mode 100644
index 00000000..697b2639
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/app/PartialInterpretationMetricDistance.xtend
@@ -0,0 +1,216 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.EuclideanDistance
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.JSDistance
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.KSDistance
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance.StateData
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.graph.PartialInterpretationGraph
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io.RepMetricsReader
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.Metric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MetricSampleGroup
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MultiplexParticipationCoefficientMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.NodeActivityMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.NodeTypeMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.OutDegreeMetric
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.predictor.LinearModel
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.List
+import java.util.Map
+import org.apache.commons.math3.stat.regression.OLSMultipleLinearRegression
+import org.eclipse.xtend.lib.annotations.Accessors
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.EdgeTypeMetric
+
+class PartialInterpretationMetricDistance {
+        
+        var KSDistance ks;
+        var JSDistance js;
+        var EuclideanDistance ed;
+        var Map<Object, StateData> stateAndHistory;
+        var OLSMultipleLinearRegression regression;
+        List<StateData> samples;
+        var MetricSampleGroup g;
+        @Accessors(PUBLIC_GETTER)
+        var LinearModel linearModel;
+        
+        
+        new(Domain d){
+                var metrics = RepMetricsReader.read(d);
+                this.g = metrics;
+                ks = new KSDistance(g);
+                js = new JSDistance(g);
+                ed = new EuclideanDistance(g);
+                regression = new OLSMultipleLinearRegression();
+                regression.noIntercept = false;
+                stateAndHistory = new HashMap<Object, StateData>();
+                samples = new ArrayList<StateData>();
+                linearModel = new LinearModel(0.01);
+        }
+        
+        def MetricDistanceGroup calculateMetricDistanceKS(PartialInterpretation partial){
+                val metrics = new ArrayList<Metric>();
+                metrics.add(new OutDegreeMetric());
+                metrics.add(new NodeActivityMetric());
+                metrics.add(new MultiplexParticipationCoefficientMetric());
+                metrics.add(new NodeTypeMetric());
+                val metricCalculator = new PartialInterpretationGraph(partial, metrics, null);          
+                var metricSamples = metricCalculator.evaluateAllMetricsToSamples();
+                
+                var mpc = ks.mpcDistance(metricSamples.mpcSamples);
+                var na = ks.naDistance(metricSamples.naSamples);
+                var outDegree = ks.outDegreeDistance(metricSamples.outDegreeSamples);
+                var nodeType = ks.nodeTypeDistance(metricSamples.nodeTypeSamples);
+                //var typedOutDegree = ks.typedOutDegreeDistance(metricSamples.typedOutDegreeSamples);
+                var distance = new MetricDistanceGroup(mpc, na, outDegree, nodeType);
+                distance.nodeTypeInfo = metricSamples.nodeTypeSamples;
+                return distance;
+        }
+        
+        def MetricDistanceGroup calculateMetricEuclidean(PartialInterpretation partial){
+                val metrics = new ArrayList<Metric>();
+                metrics.add(new OutDegreeMetric());
+                metrics.add(new NodeActivityMetric());
+                metrics.add(new MultiplexParticipationCoefficientMetric());
+                
+                val metricCalculator = new PartialInterpretationGraph(partial, metrics, null);          
+                var metricSamples = metricCalculator.evaluateAllMetricsToSamples();
+                
+                var mpc = ed.mpcDistance(metricSamples.mpcSamples);
+                var na = ed.naDistance(metricSamples.naSamples);
+                var outDegree = ed.outDegreeDistance(metricSamples.outDegreeSamples);
+                
+                return new MetricDistanceGroup(mpc, na, outDegree);
+        }
+        
+        def MetricDistanceGroup calculateMetricDistance(PartialInterpretation partial){
+                val metrics = new ArrayList<Metric>();
+                metrics.add(new OutDegreeMetric());
+                metrics.add(new NodeActivityMetric());
+                metrics.add(new MultiplexParticipationCoefficientMetric());
+                
+                val metricCalculator = new PartialInterpretationGraph(partial, metrics, null);          
+                var metricSamples = metricCalculator.evaluateAllMetricsToSamples();
+                
+                var mpc = js.mpcDistance(metricSamples.mpcSamples);
+                var na = js.naDistance(metricSamples.naSamples);
+                var outDegree = js.outDegreeDistance(metricSamples.outDegreeSamples);
+                
+                return new MetricDistanceGroup(mpc, na, outDegree);
+        }
+        
+        def resetRegression(Object state){
+                samples.clear();
+                
+                if(stateAndHistory.containsKey(state)){
+                        var data = stateAndHistory.get(state);
+                        
+                        var curState = state;
+                        
+                        samples.add(data);
+                        
+                        while(stateAndHistory.containsKey(data.lastState) && data.lastState != curState){
+                                curState = data.lastState;
+                                data = stateAndHistory.get(data.lastState);
+                                samples.add(data);
+                        }
+                                        
+                        if(samples.size == 0){
+                                println('state: ' + state);
+                                println('last state: ' + data.lastState);
+                        }
+                }
+                println("trajectory sample size:" + samples.size)
+        }
+        
+        def feedData(Object state, double[] features, double value, Object lastState){
+                var data = new StateData(features, value, lastState);
+                stateAndHistory.put(state, data);
+                samples.add(data);
+        }
+        
+        def getPredictionForNextDataSample(double[] features, double value, double[] featuresToPredict){        
+                if(samples.size <= 4){
+                        println('OK');
+                }       
+                var data = new StateData(features, value, null);
+                samples.add(data);
+                
+                // create training set from current data                
+                var double[][] xSamples = samples.map[it.features];
+                var double[] ySamples = samples.map[it.value];
+                
+                
+                regression.newSampleData(ySamples, xSamples);
+                var prediction = predict(featuresToPredict);    
+                
+                //remove the last element just added
+                samples.remove(samples.size - 1);
+                return prediction;
+        }
+        
+        def private predict(double[] featuresToPredict){
+                var parameters = regression.estimateRegressionParameters();
+                // the regression will add an initial column for 1's, the first parameter is constant term
+                var result = parameters.get(0);
+                for(var i = 0; i < featuresToPredict.length; i++){
+                        result += parameters.get(i+1) * featuresToPredict.get(i);
+                }
+                return result;
+        }
+        
+        def double[] calculateFeature(int step, int violations){
+                var features = newDoubleArrayOfSize(2);
+                //constant term
+                features.set(0, 1); //a
+                features.set(0, Math.sqrt(step) + 30) // b
+                features.set(1, 1.0 / (step + 30) );// c
+                
+                
+//              features.set(2, violations);
+//              features.set(3, Math.pow(violations, 2));
+                
+                return features;
+        }
+}
+
+class MetricDistanceGroup{
+        var double mpcDistance;
+        var double naDistance;
+        var double outDegreeDistance;
+        var double nodeTypeDistance;
+        protected var HashMap<String, Double> nodeTypeInfo;
+                
+        new(double mpcDistance, double naDistance, double outDegreeDistance, double nodeTypeDistance){
+                this.mpcDistance = mpcDistance;
+                this.naDistance = naDistance;
+                this.outDegreeDistance = outDegreeDistance;
+                this.nodeTypeDistance = nodeTypeDistance;
+        }
+        
+        new(double mpcDistance, double naDistance, double outDegreeDistance){
+                this.mpcDistance = mpcDistance;
+                this.naDistance = naDistance;
+                this.outDegreeDistance = outDegreeDistance;
+        }
+        
+        def double getNodeTypeDistance(){
+                return this.nodeTypeDistance;
+        }
+        
+        def double getMPCDistance(){
+                return this.mpcDistance
+        }
+        
+        def double getNADistance(){
+                return this.naDistance
+        }
+        
+        def double getOutDegreeDistance(){
+                return this.outDegreeDistance
+        }
+        
+        def double getNodeTypePercentage(String typeName){
+                return nodeTypeInfo.getOrDefault(typeName, 0.0);
+        }
+}
\ No newline at end of file