add realistic solver

4 files changed, 300 insertions, 0 deletions

diff --git a/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/CostDistance.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/CostDistance.xtend
new file mode 100644
index 00000000..613f0f43
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/CostDistance.xtend
@@ -0,0 +1,38 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance
+
+import java.text.DecimalFormat
+import java.util.HashMap
+import java.util.List
+import org.eclipse.xtend.lib.annotations.Accessors
+
+abstract class CostDistance {
+        def abstract double naDistance(List<Double> samples);   
+        def abstract double mpcDistance(List<Double> samples);
+        def abstract double outDegreeDistance(List<Double> samples);
+        
+        def protected pmfFromSamples(double[] samples, DecimalFormat formatter){
+                var length = samples.length;
+                var pmfMap = new HashMap<String, Double>();
+                
+                for(sample : samples){
+                        pmfMap.put(formatter.format(sample), pmfMap.getOrDefault(formatter.format(sample), 0.0) + 1.0 / length);
+                }
+                
+                return pmfMap;
+        }
+}
+
+class StateData{
+        @Accessors(PUBLIC_GETTER)
+        var double[] features;
+        @Accessors(PUBLIC_GETTER)
+        var double value;
+        @Accessors(PUBLIC_GETTER)
+        var Object lastState;
+        
+        new(double[] features, double value, Object lastState){
+                this.features = features;
+                this.value = value
+                this.lastState = lastState;
+        }
+}
\ 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/distance/EuclideanDistance.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/EuclideanDistance.xtend
new file mode 100644
index 00000000..d6adcc9a
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/EuclideanDistance.xtend
@@ -0,0 +1,72 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.app.Domain
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.io.RepMetricsReader
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MetricSampleGroup
+import com.google.common.collect.Sets
+import java.text.DecimalFormat
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.List
+import java.util.Map
+import java.util.Set
+
+class EuclideanDistance extends CostDistance{
+        var MetricSampleGroup g;
+        var HashMap<String, Double> mpcPMF;
+        var HashMap<String, Double> naPMF;
+        var HashMap<String, Double> outDegreePMF;
+        var DecimalFormat formatter;
+        
+        new(MetricSampleGroup g){
+                this.g = g;
+                
+                var mpcSamples = g.mpcSamples;
+                var naSamples = g.naSamples.stream.mapToDouble([it]).toArray();
+                var outDegreeSamples = g.outDegreeSamples.stream.mapToDouble([it]).toArray();
+                
+                //needs to format the number to string avoid precision issue
+                formatter = new DecimalFormat("#0.00000");  
+                
+                mpcPMF = pmfFromSamples(mpcSamples, formatter);
+                naPMF = pmfFromSamples(naSamples, formatter);
+                outDegreePMF = pmfFromSamples(outDegreeSamples, formatter);     
+        }
+        
+        override naDistance(List<Double> samples) {
+                var pmfMap = pmfFromSamples(samples, formatter);
+                return euclideanDistance(pmfMap, naPMF);
+        }
+        
+        override mpcDistance(List<Double> samples) {
+                var pmfMap = pmfFromSamples(samples, formatter);
+                return euclideanDistance(pmfMap, mpcPMF);
+        }
+        
+        override outDegreeDistance(List<Double> samples) {
+                var pmfMap = pmfFromSamples(samples, formatter);
+                return euclideanDistance(pmfMap, outDegreePMF);
+        }
+        
+        
+        def private euclideanDistance(HashMap<String, Double> pmf1, HashMap<String, Double> pmf2){
+                var keys = Sets.union(pmf1.keySet(), pmf2.keySet());
+                var pmfList1 = pmfMapToList(pmf1, keys);
+                var pmfList2 = pmfMapToList(pmf2, keys);
+                var distance = 0.0;
+                for(var i = 0; i < pmfList1.size(); i++){
+                        distance += Math.pow(pmfList1.get(i) + pmfList2.get(i), 2);
+                }
+                
+                return Math.sqrt(distance);
+        }       
+        
+        def private pmfMapToList(Map<String, Double> map, Set<String> keys){
+                var list = new ArrayList<Double>();
+                for(key : keys){
+                        var value = map.getOrDefault(key, 0.0);
+                        list.add(value);
+                }
+                return list;
+        }
+}
\ 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/distance/JSDistance.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/JSDistance.xtend
new file mode 100644
index 00000000..4a0a0dc3
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/JSDistance.xtend
@@ -0,0 +1,88 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MetricSampleGroup
+import com.google.common.collect.Sets
+import java.text.DecimalFormat
+import java.util.HashMap
+import java.util.List
+
+class JSDistance extends CostDistance {
+        var HashMap<String, Double> mpcPMF;
+        var HashMap<String, Double> naPMF;
+        var HashMap<String, Double> outDegreePMF;
+        var HashMap<String, Double> nodeTypesPMF;
+        var DecimalFormat formatter;
+        
+        new(MetricSampleGroup g){
+                var mpcSamples = g.mpcSamples;
+                var naSamples = g.naSamples.stream.mapToDouble([it]).toArray();
+                var outDegreeSamples = g.outDegreeSamples.stream.mapToDouble([it]).toArray();
+                
+                //needs to format the number to string avoid precision issue
+                formatter = new DecimalFormat("#0.00000");  
+                
+                mpcPMF = pmfFromSamples(mpcSamples, formatter);
+                naPMF = pmfFromSamples(naSamples, formatter);
+                outDegreePMF = pmfFromSamples(outDegreeSamples, formatter);     
+                nodeTypesPMF = g.nodeTypeSamples; 
+        }
+        
+        def private combinePMF(HashMap<String, Double> pmf1, HashMap<String, Double> pmf2){
+                var pmfMap = new HashMap<String, Double>();
+                
+                var union = Sets.union(pmf1.keySet(), pmf2.keySet());
+                
+                for(key : union){
+                        // corresponding to M in JS distance
+                        var value = 1.0/2 * (pmf1.getOrDefault(key, 0.0) + pmf2.getOrDefault(key, 0.0));
+                        pmfMap.put(key, value);
+                }
+                return pmfMap;
+        }
+        
+        def private jsDivergence(HashMap<String, Double> p, HashMap<String, Double> q){
+                val m = combinePMF(q, p);
+                var distance = 1.0/2 * klDivergence(p, m) + 1.0/2 * klDivergence(q, m);
+                return distance;
+        }
+        
+        def klDivergence(HashMap<String, Double> p, HashMap<String, Double> q){
+                var distance = 0.0;
+                for(key : q.keySet()){
+                        //need to convert log e to log 2
+                        if(p.containsKey(key)){
+                                distance -= p.get(key) * Math.log(q.get(key) / p.get(key)) / Math.log(2);
+                        }
+                }
+                return distance;
+        }
+        
+        override double mpcDistance(List<Double> samples){
+                // map list to array
+                var map = pmfFromSamples(samples.stream().mapToDouble([it]).toArray(), formatter);
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(map.size < 2) return 1;
+                return jsDivergence(map, mpcPMF);
+        }
+        
+        override double naDistance(List<Double> samples){
+                // map list to array
+                var map = pmfFromSamples(samples.stream().mapToDouble([it]).toArray(), formatter);
+                
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(map.size < 2) return 1;
+                return jsDivergence(map, naPMF);
+        }
+        
+        override double outDegreeDistance(List<Double> samples){
+                // map list to array
+                var map = pmfFromSamples(samples.stream().mapToDouble([it]).toArray(), formatter);
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(map.size < 2) return 1;
+                return jsDivergence(map, outDegreePMF);
+        }
+        
+        def nodeTypeDistance(HashMap<String, Double> samples){
+                return klDivergence(samples, nodeTypesPMF);
+        }
+}
\ 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/distance/KSDistance.xtend b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/KSDistance.xtend
new file mode 100644
index 00000000..c486a328
--- /dev/null
+++ b/Metrics/Metrics-Calculation/ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator/src/ca/mcgill/ecse/dslreasoner/realistic/metrics/calculator/distance/KSDistance.xtend
@@ -0,0 +1,102 @@
+package ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.distance
+
+import ca.mcgill.ecse.dslreasoner.realistic.metrics.calculator.metrics.MetricSampleGroup
+import java.util.HashMap
+import java.util.HashSet
+import java.util.List
+import org.apache.commons.math3.stat.inference.KolmogorovSmirnovTest
+
+class KSDistance extends CostDistance {
+        var static ksTester = new KolmogorovSmirnovTest();
+        var MetricSampleGroup g;
+        
+        new(MetricSampleGroup g){
+                this.g = g;     
+        }
+        override double mpcDistance(List<Double> samples){
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(samples.size < 2) return 1;
+                return ksTester.kolmogorovSmirnovStatistic(g.mpcSamples, samples);
+        }
+        
+        override double naDistance(List<Double> samples){
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(samples.size < 2) return 1;
+                return ksTester.kolmogorovSmirnovStatistic(g.naSamples as double[], samples);
+        }
+        
+        override double outDegreeDistance(List<Double> samples){
+                //if the size of array is smaller than 2, ks distance cannot be performed, simply return 1
+                if(samples.size < 2) return 1;
+                return ksTester.kolmogorovSmirnovStatistic(g.outDegreeSamples, samples);
+        }
+        
+        def double typedOutDegreeDistance(HashMap<String, List<Integer>> map){
+                var value = 0.0;
+                // map list to array
+                val keySet = new HashSet<String>(map.keySet);
+                keySet.addAll(g.typedOutDegreeSamples.keySet);
+                for(key : keySet){
+                        if(!map.containsKey(key) ){
+                                value += 1;
+                        }else if(!g.typedOutDegreeSamples.containsKey(key)){
+                                value += map.get(key).size * 100;       
+                        }else{
+                                var double[] rep = g.typedOutDegreeSamples.get(key).stream().mapToDouble([it|it]).toArray();
+                                var double[] ins = map.get(key).stream().mapToDouble([it|it]).toArray();
+                                if((rep.size < 2 || ins.size < 2) ){
+                                        if(rep.size < 2 && rep.containsAll(ins)){
+                                                value += 0;
+                                        }else{
+                                                value += 1;
+                                        }
+                                }else if(rep.size >= 2 && ins.size >= 2){
+                                        value += ksTester.kolmogorovSmirnovStatistic(rep, ins);
+                                }
+                        }
+                } 
+                
+                
+                return value;
+        }
+        
+        def nodeTypeDistance(HashMap<String, Double> samples){
+                var typesDistMap = g.nodeTypeSamples;
+                var sourceDist = newArrayList();
+                var instanceDist = newArrayList();
+                
+                for(key : typesDistMap.keySet()){
+                        sourceDist.add(typesDistMap.get(key));
+                        instanceDist.add(samples.getOrDefault(key, 0.0));
+                }
+                
+                return ks_distance_two_dist(sourceDist, instanceDist);
+        }
+        
+        def edgeTypeDistance(HashMap<String, Double> samples){
+                var typesDistMap = g.edgeTypeSamples;
+                var sourceDist = newArrayList();
+                var instanceDist = newArrayList();
+                
+                for(key : typesDistMap.keySet()){
+                        sourceDist.add(typesDistMap.get(key));
+                        instanceDist.add(samples.getOrDefault(key, 0.0));
+                }
+                
+                return ks_distance_two_dist(sourceDist, instanceDist);
+        }
+        
+        def double ks_distance_two_dist(List<Double> dist1, List<Double> dist2){
+                // Since we already know the pdf, we compute the ks-test manully
+                var ksStatistics = 0.0;
+                var sum1 = 0.0;
+                var sum2 = 0.0;
+                for(var i = 0; i < dist1.size(); i++){
+                        sum1 += dist1.get(i);
+                        sum2 += dist2.get(i);
+                        
+                        ksStatistics = Math.max(ksStatistics, Math.abs(sum1 - sum2));
+                } 
+                return ksStatistics;
+        }
+}
\ No newline at end of file