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

Timestamp:

07/13/21 14:38:02 (3 years ago)

Author:

gkronber

Message:

#3087: removed "strings-enums" in ParameterOptimizer and do not derive ParameterOptimizer from NativeInterpreter (+ renamed enum types in CeresTypes)

File:

• branches/3087_Ceres_Integration/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/NativeInterpreter.cs (modified) (7 diffs)

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

@@ -38 +38 @@
   [StorableType("91723319-8F15-4D33-B277-40AC7C7CF9AE")]
   [Item("NativeInterpreter", "Operator calling into native C++ code for tree interpretation.")]
-  public class NativeInterpreter : ParameterizedNamedItem, ISymbolicDataAnalysisExpressionTreeInterpreter {
+  public sealed class NativeInterpreter : ParameterizedNamedItem, ISymbolicDataAnalysisExpressionTreeInterpreter {
     private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
 
@@ -58 +58 @@
     }
 
+    #region storable ctor and cloning
     [StorableConstructor]
-    protected NativeInterpreter(StorableConstructorFlag _) : base(_) { }
-
-    protected NativeInterpreter(NativeInterpreter original, Cloner cloner) : base(original, cloner) {
-    }
-
+    private NativeInterpreter(StorableConstructorFlag _) : base(_) { }
     public override IDeepCloneable Clone(Cloner cloner) {
       return new NativeInterpreter(this, cloner);
     }
+
+    private NativeInterpreter(NativeInterpreter original, Cloner cloner) : base(original, cloner) { }
+    #endregion
+
     public static NativeInstruction[] Compile(ISymbolicExpressionTree tree, IDataset dataset, Func<ISymbolicExpressionTreeNode, byte> opCodeMapper, out List<ISymbolicExpressionTreeNode> nodes) {
       var root = tree.Root.GetSubtree(0).GetSubtree(0);
@@ -73 +74 @@
 
     public static NativeInstruction[] Compile(ISymbolicExpressionTreeNode root, IDataset dataset, Func<ISymbolicExpressionTreeNode, byte> opCodeMapper, out List<ISymbolicExpressionTreeNode> nodes) {
-      if (cachedData == null || cachedDataset != dataset) {
+      if (cachedData == null || cachedDataset != dataset || cachedDataset is ModifiableDataset) {
         InitCache(dataset);
       }
-
+      
       nodes = root.IterateNodesPrefix().ToList(); nodes.Reverse();
       var code = new NativeInstruction[nodes.Count];
-
-      for (int i = 0; i < nodes.Count; ++i) {
-        var node = nodes[i];
-        code[i] = new NativeInstruction { Arity = (ushort)node.SubtreeCount, OpCode = opCodeMapper(node), Length = (ushort)node.GetLength(), Optimize = true };
-
-        if (node is VariableTreeNode variable) {
+      if (root.SubtreeCount > ushort.MaxValue) throw new ArgumentException("Number of subtrees is too big (>65.535)");
+      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 (node is ConstantTreeNode constant) {
+        } 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;
+        }
+      }
+
       return code;
+    }
+
+    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows) {
+      return GetSymbolicExpressionTreeValues(tree, dataset, rows.ToArray());
+    }
+
+    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, int[] rows) {
+      if (!rows.Any()) return Enumerable.Empty<double>();
+
+      byte mapSupportedSymbols(ISymbolicExpressionTreeNode node) {
+        var opCode = OpCodes.MapSymbolToOpCode(node);
+        if (supportedOpCodes.Contains(opCode)) return opCode;
+        else throw new NotSupportedException($"The native interpreter does not support {node.Symbol.Name}");
+      };
+      var code = Compile(tree, dataset, mapSupportedSymbols, out List<ISymbolicExpressionTreeNode> nodes);
+
+      var result = new double[rows.Length];
+      var options = new SolverOptions { Iterations = 0 }; // Evaluate only. Do not optimize.
+
+      NativeWrapper.GetValues(code, rows, options, result, target: null, out var summary);
+
+      // when evaluation took place without any error, we can increment the counter
+      lock (syncRoot) {
+        EvaluatedSolutions++;
+      }
+
+      return result;
     }
 
@@ -102 +139 @@
     private static IDataset cachedDataset;
 
-    protected static readonly HashSet<byte> supportedOpCodes = new HashSet<byte>() {
+    private static readonly HashSet<byte> supportedOpCodes = new HashSet<byte>() {
       (byte)OpCode.Constant,
       (byte)OpCode.Variable,
@@ -115 +152 @@
       (byte)OpCode.Tan,
       (byte)OpCode.Tanh,
-      (byte)OpCode.Power,
-      (byte)OpCode.Root,
+      // (byte)OpCode.Power, // these symbols are handled differently in the NativeInterpreter than in HL
+      // (byte)OpCode.Root,
       (byte)OpCode.SquareRoot,
       (byte)OpCode.Square,
@@ -125 +162 @@
     };
 
-    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows) {
-      return GetSymbolicExpressionTreeValues(tree, dataset, rows.ToArray());
-    }
-    
     private static void InitCache(IDataset dataset) {
       cachedDataset = dataset;
@@ -159 +192 @@
       ClearState();
     }
-
-    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, int[] rows) {
-      if (!rows.Any()) return Enumerable.Empty<double>();
-
-      byte mapSupportedSymbols(ISymbolicExpressionTreeNode node) {
-        var opCode = OpCodes.MapSymbolToOpCode(node);
-        if (supportedOpCodes.Contains(opCode)) return opCode;
-        else throw new NotSupportedException($"The native interpreter does not support {node.Symbol.Name}");
-      };
-      var code = Compile(tree, dataset, mapSupportedSymbols, out List<ISymbolicExpressionTreeNode> nodes);
-
-      var result = new double[rows.Length];
-      var options = new SolverOptions { /* not using any options here */ };
-
-      var summary = new OptimizationSummary(); // also not used
-      NativeWrapper.GetValues(code, rows, options, result, target: null, out summary);
-
-      // when evaluation took place without any error, we can increment the counter
-      lock (syncRoot) {
-        EvaluatedSolutions++;
-      }
-
-      return result;
-    }
   }
 }