Changeset 16313

Timestamp:

11/21/18 10:27:55 (6 years ago)

Author:

chaider

Message:

#2956:

• Updated value visualization of simplifier tooltip
• Added VariableRanges field to dataset
• Added overloads for GetSymbolicExressionTreeIntervals

Location:

branches/2956_apriori_knowledge

Files:

• HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Interpreter/SymbolicDataAnalysisIntervalArithmeticInterpreter.cs (modified) (3 diffs)
• HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Plugin.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs (modified) (5 diffs)

branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Interpreter/SymbolicDataAnalysisIntervalArithmeticInterpreter.cs

@@ -42 +42 @@
     private readonly object syncRoot = new object();
 
-    private static InterpreterState PrepareInterpreterState(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows, Dictionary<string, Interval> customIntervals = null) {
+    private static InterpreterState PrepareInterpreterState(ISymbolicExpressionTree tree, 
+      IEnumerable<int> rows, IDataset dataset = null, Dictionary<string, Interval> customIntervals = null) {
       Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
       int necessaryArgStackSize = 0;
@@ -51 +52 @@
           IList<double> values = new List<double>();
 
-          if (customIntervals != null && customIntervals.ContainsKey(variableTreeNode.VariableName)) {
-            instr.data = customIntervals[variableTreeNode.VariableName];
+          if (dataset != null && customIntervals != null) {
+            if (customIntervals.ContainsKey(variableTreeNode.VariableName)) {
+              instr.data = customIntervals[variableTreeNode.VariableName];
+            } else {
+              foreach (var rowEnum in rows) {
+                values.Add(dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName)[rowEnum]);
+              }
+              instr.data = new Interval(values.Min(), values.Max());
+            }
+          } else if (dataset != null) {
+             foreach (var rowEnum in rows) {
+              values.Add(dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName)[rowEnum]);
+            }
+            instr.data = new Interval(values.Min(), values.Max());
+          } else if (customIntervals != null) {
+            if (customIntervals.ContainsKey(variableTreeNode.VariableName)) { 
+              instr.data = customIntervals[variableTreeNode.VariableName];
+            }
           } else {
-            foreach (var rowEnum in rows) {
-              values.Add(dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName)[rowEnum]);
-            }
-            instr.data = new Interval(values.Min(), values.Max());
+            throw new Exception("No valid input for variables!");
           }
         }
@@ -204 +218 @@
     //  var x = Evaluate(dataset, state);
     //  state.Reset();
-      
+
     //  return state;
     //}
 
-   // public Interval GetSymbolicExressionTreeInterval(tree,variableIntervals)
+    // public Interval GetSymbolicExressionTreeInterval(tree,variableIntervals)
     //public Interval GetSymbolicExressionTreeInterval(tree,Dataset,intervals = null)
+
+    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IEnumerable<int> rows, out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
+      intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
+      var state = PrepareInterpreterState(tree, rows);
+      var x = Evaluate(state, intervals);
+
+      return x;
+    }
+
+    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows,
+      Dictionary<string, Interval> customIntervals, out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
+      intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
+      var state = PrepareInterpreterState(tree, rows, dataset, customIntervals);
+      var x = Evaluate(state, intervals);
+
+      return x;
+    }
+
     public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows, 
       out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
       intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
-      var state = PrepareInterpreterState(tree, dataset, rows);
+      var state = PrepareInterpreterState(tree, rows, dataset);
       var x = Evaluate(state, intervals);
       

branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Plugin.cs

@@ -29 +29 @@
 namespace HeuristicLab.Algorithms.DataAnalysis.IntervalArithmetic
 {
-    [Plugin("HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntergration", "3.4.0.0")]
+    [Plugin("HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntergration", "3.4.0.16303")]
     [PluginFile("HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration-3.4.dll", PluginFileType.Assembly)]
     public class Plugin : PluginBase{

branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs

@@ -34 +34 @@
 using HeuristicLab.MainForm;
 using HeuristicLab.MainForm.WindowsForms;
+using System.Globalization;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
@@ -193 +194 @@
       var interpreter = new SymbolicDataAnalysisIntervalArithmeticInterpreter();
 
-      //var intervalParam = ((IRegressionProblemData)Content.ProblemData).IntervalVariable;
+      //Get the Variable Ranges and add it to the dictionary 
+      var intervalParameters = ((IRegressionProblemData)Content.ProblemData).VariableRanges;
       var customIntervals = new Dictionary<String, Interval>();
-      var parser = new FormulationParser();
-      //foreach (var ci in intervalParam) {
-      //var inter = parser.Parse(ci.Formulation.GetValue());
-      //customIntervals.Add(ci.Variable.GetValue(), new Interval(0, 1));
-      //}
-      var resultInterval = interpreter.GetSymbolicExressionTreeIntervals(tree, Content.ProblemData.Dataset, Content.ProblemData.TrainingIndices, out intervals);
+      for (int x = 0; x < intervalParameters.Rows; ++x) {
+        customIntervals.Add(intervalParameters.RowNames.ElementAt(x),
+                            new Interval(intervalParameters.GetRow(x).ElementAt(0),
+                                         intervalParameters.GetRow(x).ElementAt(1)));
+      }
+
+      var resultInterval = interpreter.GetSymbolicExressionTreeIntervals(tree, Content.ProblemData.Dataset, Content.ProblemData.TrainingIndices, customIntervals, out intervals);
       await Task.Delay(500); // wait for progressbar to finish animation
       var replacementValues = impactAndReplacementValues.ToDictionary(x => x.Key, x => x.Value.Item2);
@@ -206 +209 @@
         foldedNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
       }
-      //Instruction currentInstr = instructions.NextInstruction();
-      //while (instructions.HasNextInstruction()) {
-      //  //intervals[currentInstr.dynamicNode] = (Interval)currentInstr.data;
-      //  intervals.Add(Tuple.Create(currentInstr.dynamicNode, (Interval)currentInstr.data));
-      //  currentInstr = instructions.NextInstruction();
-      //}
-      
-      
-
-      //intervals.Add(Tuple.Create(currentInstr.dynamicNode, (Interval)currentInstr.data));
+
       nodeImpacts = impactAndReplacementValues.ToDictionary(x => x.Key, x => x.Value.Item1);
       progress.Finish();
       PaintIntervals();
-      //PaintNodeImpacts();
     }
 
@@ -291 +284 @@
         if (visualTree != null) { 
           visualTree.ToolTip = visualTree.Content.ToString();
-          //visualTree.ToolTip += String.Format($"{Environment.NewLine}Intervals: [{intervals[node].Item2.LowerBound:E4} ... {intervals[node].Item2.UpperBound:E4}]{Environment.NewLine}");
-          visualTree.ToolTip += String.Format($"{Environment.NewLine}Intervals: [{intervals[treeNode].LowerBound:E4} ... {intervals[treeNode].UpperBound:E4}]{Environment.NewLine}]");
+          visualTree.ToolTip += String.Format($"{Environment.NewLine}Intervals: [{intervals[treeNode].LowerBound:G5} ... {intervals[treeNode].UpperBound:G5}]{Environment.NewLine}");
           node++;
           
@@ -309 +301 @@
               visualTree.FillColor = Color.FromArgb((int)(impact / max * 255), Color.Green);
             }
-            visualTree.ToolTip += String.Format($"{Environment.NewLine} Node impact: {impact:E4}");
+            visualTree.ToolTip += String.Format($"Node impact: {impact:G5}");
             var constantReplacementNode = foldedNodes[treeNode] as ConstantTreeNode;
             if (constantReplacementNode != null) {
-              visualTree.ToolTip += String.Format($"{Environment.NewLine} Replacement value: {constantReplacementNode.Value:E4}");
+              visualTree.ToolTip += String.Format($"{Environment.NewLine}Replacement value: {constantReplacementNode.Value:G5}");
             }
           }