Changeset 17989 for branches/3087_Ceres_Integration/HeuristicLab.Problems.DataAnalysis.Symbolic

Timestamp:

06/16/21 21:15:16 (4 years ago)

Author:

gkronber

Message:

#3087: updated native dlls for NativeInterpreter to a version that runs on Hive infrastructure. Some smaller changes because of deviations in the independently developed implementations (in particular enum types).

Location:

branches/3087_Ceres_Integration/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter

Files:

• NativeInterpreter.cs (modified) (2 diffs)
• ParameterOptimizer.cs (modified) (4 diffs)
• SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs (modified) (5 diffs)

branches/3087_Ceres_Integration/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/NativeInterpreter.cs

@@ -31 +31 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.NativeInterpreter;
 using HeuristicLab.Parameters;
 using HeuristicLab.Problems.DataAnalysis;
@@ -173 +174 @@
 
       var summary = new OptimizationSummary(); // also not used
-      NativeWrapper.GetValues(code, rows, result, null, options, ref summary);
+      NativeWrapper.GetValues(code, rows, options, result, target: null, out summary);
 
       // when evaluation took place without any error, we can increment the counter

branches/3087_Ceres_Integration/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/ParameterOptimizer.cs

@@ -7 +7 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.NativeInterpreter;
 using HeuristicLab.Parameters;
 
@@ -84 +85 @@
       set { UseNonmonotonicStepsParameter.Value.Value = value; }
     }
-    private int Minimizer {
-      get { return Array.IndexOf(MinimizerType, MinimizerTypeParameter.Value.Value); }
-    }
-    private int LinearSolver {
-      get { return Array.IndexOf(LinerSolverType, LinearSolverTypeParameter.Value.Value); }
-    }
-    private int TrustRegionStrategy {
-      get { return Array.IndexOf(TrustRegionStrategyType, TrustRegionStrategyTypeParameter.Value.Value); }
-    }
-    private int Dogleg {
-      get { return Array.IndexOf(DoglegType, DogLegTypeParameter.Value.Value); }
-    }
-    private int LineSearchDirection {
-      get { return Array.IndexOf(LinearSearchDirectionType, LineSearchDirectionTypeParameter.Value.Value); }
+    private CeresTypes.MinimizerType Minimizer {
+      get { return (CeresTypes.MinimizerType)Enum.Parse(typeof(CeresTypes.MinimizerType), MinimizerTypeParameter.Value.Value); }
+    }
+    private CeresTypes.LinearSolverType LinearSolver {
+      get { return (CeresTypes.LinearSolverType)Enum.Parse(typeof(CeresTypes.LinearSolverType), LinearSolverTypeParameter.Value.Value); }
+    }
+    private CeresTypes.TrustRegionStrategyType TrustRegionStrategy {
+      get { return (CeresTypes.TrustRegionStrategyType)Enum.Parse(typeof(CeresTypes.TrustRegionStrategyType), TrustRegionStrategyTypeParameter.Value.Value); }
+    }
+    private CeresTypes.DoglegType Dogleg {
+      get { return (CeresTypes.DoglegType)Enum.Parse(typeof(CeresTypes.DoglegType), DogLegTypeParameter.Value.Value); }
+    }
+    private CeresTypes.LineSearchDirectionType LineSearchDirection {
+      get { return (CeresTypes.LineSearchDirectionType)Enum.Parse(typeof(CeresTypes.LineSearchDirectionType), LineSearchDirectionTypeParameter.Value.Value); }
     }
     #endregion
@@ -147 +148 @@
         var result = new double[rowsArray.Length];
 
-        NativeWrapper.GetValues(code, rowsArray, result, target, options, ref summary);
+        NativeWrapper.GetValues(code, rowsArray, options, result, target, out summary);
       }
       return Enumerable.Range(0, code.Length).Where(i => nodes[i] is SymbolicExpressionTreeTerminalNode).ToDictionary(i => nodes[i], i => code[i].Value);
@@ -201 +202 @@
       var codeArray = totalCode.ToArray();
 
-      NativeWrapper.GetValuesVarPro(codeArray, termIndices, rowsArray, coeff, result, target, options, ref summary);
+      NativeWrapper.GetValuesVarPro(codeArray, termIndices,rowsArray, coeff, options, result, target, out summary);
       return Enumerable.Range(0, totalCodeSize).Where(i => codeArray[i].Optimize).ToDictionary(i => totalNodes[i], i => codeArray[i].Value);
     }

branches/3087_Ceres_Integration/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs

@@ -28 +28 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.NativeInterpreter;
 using HeuristicLab.Parameters;
 using HEAL.Attic;
@@ -70 +71 @@
       var code = new NativeInstruction[root.GetLength()];
       if (root.SubtreeCount > ushort.MaxValue) throw new ArgumentException("Number of subtrees is too big (>65.535)");
-      code[0] = new NativeInstruction { 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 NativeInstruction { narg = (ushort)s.SubtreeCount, opcode = opCodeMapper(s) };
+      int i = code.Length - 1;
+      foreach (var n in root.IterateNodesPrefix()) {
+        code[i] = new NativeInstruction { Arity = (ushort)n.SubtreeCount, OpCode = opCodeMapper(n), Length = 1, Optimize = false };
+        if (n is VariableTreeNode variable) {
+          code[i].Value = variable.Weight;
+          code[i].Data = cachedData[variable.VariableName].AddrOfPinnedObject();
+        } else if (n is ConstantTreeNode constant) {
+          code[i].Value = constant.Value;
         }
+        --i;
+      }
+      // second pass to calculate lengths
+      for (i = 0; i < code.Length; i++) {
+        var c = i - 1;
+        for (int j = 0; j < code[i].Arity; ++j) {
+          code[i].Length += code[c].Length;
+          c -= code[c].Length;
+        }
+      }
 
-        if (node is VariableTreeNode variable) {
-          code[i].weight = variable.Weight;
-          code[i].data = cachedData[variable.VariableName].AddrOfPinnedObject();
-        } else if (node is ConstantTreeNode constant) {
-          code[i].value = constant.Value;
-        }
-
-        code[i].childIndex = c;
-        c += node.SubtreeCount;
-        ++i;
-      }
       return code;
     }
@@ -114 +115 @@
       (byte)OpCode.Tan,
       (byte)OpCode.Tanh,
-      (byte)OpCode.Power,
-      (byte)OpCode.Root,
+      // (byte)OpCode.Power,
+      // (byte)OpCode.Root,
       (byte)OpCode.SquareRoot,
       (byte)OpCode.Square,
@@ -131 +132 @@
       }
 
-      byte mapSupportedSymbols(ISymbolicExpressionTreeNode node) {        
+      byte mapSupportedSymbols(ISymbolicExpressionTreeNode node) {
         var opCode = OpCodes.MapSymbolToOpCode(node);
         if (supportedOpCodes.Contains(opCode)) return opCode;
@@ -140 +141 @@
       var rowsArray = rows.ToArray();
       var result = new double[rowsArray.Length];
-
-      NativeWrapper.GetValuesVectorized(code, code.Length, rowsArray, rowsArray.Length, result);
+      // prevent optimization of parameters
+      var options = new SolverOptions {
+        Iterations = 0
+      };
+      NativeWrapper.GetValues(code, rowsArray, options, result, target: null, optSummary: out var optSummary); // target is only used when optimizing parameters
 
       // when evaluation took place without any error, we can increment the counter