Changeset 17071 for stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter

Timestamp:

07/04/19 16:03:48 (5 years ago)

Author:

mkommend

Message:

#2958: Merged 16266, 16269, 16274, 16276, 16277, 16285, 16286, 16287, 16289, 16293, 16296, 16297, 16298, 16333, 16334 into stable.

Location:

stable

Files:

• . (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis.Symbolic (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchInstruction.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchInstruction.cs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchOperations.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchOperations.cs) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs) (10 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs)

stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchOperations.cs

@@ -64 +64 @@
         a[i] = Math.Cos(b[i]);
     }
+
+    public static void Tan(double[] a, double[] b) {
+      for (int i = 0; i < BATCHSIZE; ++i)
+        a[i] = Math.Tan(b[i]);
+    }
+
+    public static void Pow(double[] a, double[] b) {
+      for (int i = 0; i < BATCHSIZE; ++i)
+        a[i] = Math.Pow(a[i], Math.Round(b[i]));
+    }
+
+    public static void Root(double[] a, double[] b) {
+      for (int i = 0; i < BATCHSIZE; ++i)
+        a[i] = Math.Pow(a[i], 1 / Math.Round(b[i]));
+    }
+
+    public static void Square(double[] a, double[] b) {
+      for (int i = 0; i < BATCHSIZE; ++i)
+        a[i] = Math.Pow(b[i], 2d);
+    }
+
+    public static void Sqrt(double[] a, double[] b) {
+      for (int i = 0; i < BATCHSIZE; ++i)
+        a[i] = Math.Sqrt(b[i]);
+    }
   }
 }

stable/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs

@@ -11 +11 @@
 
 using static HeuristicLab.Problems.DataAnalysis.Symbolic.BatchOperations;
-//using static HeuristicLab.Problems.DataAnalysis.Symbolic.BatchOperationsVector;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -65 +64 @@
               break;
             }
+
           case OpCodes.Add: {
               Load(instr.buf, code[c].buf);
@@ -76 +76 @@
               if (n == 1) {
                 Neg(instr.buf, code[c].buf);
-                break;
               } else {
                 Load(instr.buf, code[c].buf);
@@ -82 +81 @@
                   Sub(instr.buf, code[c + j].buf);
                 }
-                break;
-              }
+              }
+              break;
             }
 
@@ -97 +96 @@
               if (n == 1) {
                 Inv(instr.buf, code[c].buf);
-                break;
               } else {
                 Load(instr.buf, code[c].buf);
@@ -103 +101 @@
                   Div(instr.buf, code[c + j].buf);
                 }
-                break;
-              }
+              }
+              break;
+            }
+
+          case OpCodes.Square: {
+              Square(instr.buf, code[c].buf);
+              break;
+            }
+
+          case OpCodes.Root: {
+              Root(instr.buf, code[c].buf);
+              break;
+            }
+
+          case OpCodes.SquareRoot: {
+              Sqrt(instr.buf, code[c].buf);
+              break;
+            }
+
+          case OpCodes.Power: {
+              Pow(instr.buf, code[c].buf);
+              break;
             }
 
@@ -116 +134 @@
               break;
             }
+
+          case OpCodes.Sin: {
+              Sin(instr.buf, code[c].buf);
+              break;
+            }
+
+          case OpCodes.Cos: {
+              Cos(instr.buf, code[c].buf);
+              break;
+            }
+
+          case OpCodes.Tan: {
+              Tan(instr.buf, code[c].buf);
+              break;
+            }
         }
       }
+    }
+
+    [ThreadStatic]
+    private Dictionary<string, double[]> cachedData;
+
+    private void InitCache(IDataset dataset) {
+      cachedData = new Dictionary<string, double[]>();
+      foreach (var v in dataset.DoubleVariables) {
+        var values = dataset.GetDoubleValues(v).ToArray();
+      }
+    }
+
+    public void InitializeState() {
+      cachedData = null;
+      EvaluatedSolutions = 0;
     }
 
     private double[] GetValues(ISymbolicExpressionTree tree, IDataset dataset, int[] rows) {
       var code = Compile(tree, dataset, OpCodes.MapSymbolToOpCode);
-
       var remainingRows = rows.Length % BATCHSIZE;
       var roundedTotal = rows.Length - remainingRows;
@@ -141 +188 @@
     }
 
+    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, int[] rows) {
+      if (cachedData == null) {
+        InitCache(dataset);
+      }
+      return GetValues(tree, dataset, rows);
+    }
+
     public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows) {
-      return GetValues(tree, dataset, rows.ToArray());
-    }
-
-    public void InitializeState() {
+      return GetSymbolicExpressionTreeValues(tree, dataset, rows.ToArray());
     }
 
@@ -152 +203 @@
       var code = new BatchInstruction[root.GetLength()];
       if (root.SubtreeCount > ushort.MaxValue) throw new ArgumentException("Number of subtrees is too big (>65.535)");
-      code[0] = new BatchInstruction { narg = (ushort)root.SubtreeCount, opcode = opCodeMapper(root) };
       int c = 1, i = 0;
       foreach (var node in root.IterateNodesBreadth()) {
-        for (int j = 0; j < node.SubtreeCount; ++j) {
-          var s = node.GetSubtree(j);
-          if (s.SubtreeCount > ushort.MaxValue) throw new ArgumentException("Number of subtrees is too big (>65.535)");
-          code[c + j] = new BatchInstruction { narg = (ushort)s.SubtreeCount, opcode = opCodeMapper(s) };
-        }
-
-        code[i].buf = new double[BATCHSIZE];
-
+        if (node.SubtreeCount > ushort.MaxValue) throw new ArgumentException("Number of subtrees is too big (>65.535)");
+        code[i] = new BatchInstruction {
+          opcode = opCodeMapper(node),
+          narg = (ushort)node.SubtreeCount,
+          buf = new double[BATCHSIZE],
+          childIndex = c
+        };
         if (node is VariableTreeNode variable) {
           code[i].weight = variable.Weight;
-          code[i].data = dataset.GetReadOnlyDoubleValues(variable.VariableName).ToArray();
+          if (cachedData.ContainsKey(variable.VariableName)) {
+            code[i].data = cachedData[variable.VariableName];
+          } else {
+            code[i].data = dataset.GetReadOnlyDoubleValues(variable.VariableName).ToArray();
+            cachedData[variable.VariableName] = code[i].data;
+          }
         } else if (node is ConstantTreeNode constant) {
           code[i].value = constant.Value;
@@ -171 +225 @@
             code[i].buf[j] = code[i].value;
         }
-
-        code[i].childIndex = c;
         c += node.SubtreeCount;
         ++i;