Changeset 16507 for branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/ConstantsOptimization/Util.cs

Timestamp:

01/06/19 18:03:15 (6 years ago)

Author:

mkommend

Message:

#2974: First stable version of new CoOp.

Location:

branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/ConstantsOptimization

Files:

• . (moved) (moved from branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Constants Optimization)
• Util.cs (modified) (3 diffs)

branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/ConstantsOptimization/Util.cs

@@ -25 +25 @@
 using HeuristicLab.Common;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using static HeuristicLab.Problems.DataAnalysis.Symbolic.TreeToAutoDiffTermConverter;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.ConstantsOptimization {
   public static class Util {
-
-    public static double[,] ExtractData(IDataset dataset, IEnumerable<DataForVariable> variables, IEnumerable<int> rows) {
-      var x = new double[rows.Count(), variables.Count()];
-
-      int row = 0;
-      foreach (var r in rows) {
-        int col = 0;
-        foreach (var variable in variables) {
-          if (dataset.VariableHasType<double>(variable.variableName)) {
-            x[row, col] = dataset.GetDoubleValue(variable.variableName, r + variable.lag);
-          } else if (dataset.VariableHasType<string>(variable.variableName)) {
-            x[row, col] = dataset.GetStringValue(variable.variableName, r) == variable.variableValue ? 1 : 0;
-          } else throw new InvalidProgramException("found a variable of unknown type");
-          col++;
-        }
-        row++;
-      }
-      return x;
-    }
-
-    public static List<DataForVariable> GenerateVariables(IDataset dataset) {
-      var variables = new List<DataForVariable>();
-      foreach (var doubleVariable in dataset.DoubleVariables) {
-        var data = new DataForVariable(doubleVariable, string.Empty, 0);
-        variables.Add(data);
-      }
-
-      foreach (var stringVariable in dataset.StringVariables) {
-        foreach (var stringValue in dataset.GetStringValues(stringVariable).Distinct()) {
-          var data = new DataForVariable(stringVariable, stringValue, 0);
+    /// <summary>
+    /// Extracts all variable information in a symbolic expression tree. The variable information is necessary to convert a tree in an AutoDiff term.
+    /// </summary>
+    /// <param name="tree">The tree referencing the variables.</param>
+    /// <returns>The data for variables occuring in the tree.</returns>
+    public static List<VariableData> ExtractVariables(ISymbolicExpressionTree tree) {
+      if (tree == null) throw new ArgumentNullException("tree");
+
+      var variables = new HashSet<VariableData>();
+      foreach (var node in tree.IterateNodesPrefix().OfType<IVariableTreeNode>()) {
+        string variableName = node.VariableName;
+        int lag = 0;
+        var laggedNode = node as ILaggedTreeNode;
+        if (laggedNode != null) lag = laggedNode.Lag;
+
+
+        var factorNode = node as FactorVariableTreeNode;
+        if (factorNode != null) {
+          foreach (var factorValue in factorNode.Symbol.GetVariableValues(variableName)) {
+            var data = new VariableData(variableName, factorValue, lag);
+            variables.Add(data);
+          }
+        } else {
+          var data = new VariableData(variableName, string.Empty, lag);
           variables.Add(data);
         }
       }
-      return variables;
-    }
-
-    public static List<DataForVariable> ExtractLaggedVariables(ISymbolicExpressionTree tree) {
-      var variables = new HashSet<DataForVariable>();
-      foreach (var laggedNode in tree.IterateNodesPrefix().OfType<ILaggedTreeNode>()) {
-        var laggedVariableTreeNode = laggedNode as LaggedVariableTreeNode;
-        if (laggedVariableTreeNode != null) {
-          var data = new DataForVariable(laggedVariableTreeNode.VariableName, string.Empty, laggedVariableTreeNode.Lag);
-          if (!variables.Contains(data)) variables.Add(data);
-        }
-      }
       return variables.ToList();
     }
-
-    public static double[] ExtractConstants(ISymbolicExpressionTree tree) {
+    /// <summary>
+    /// Extract the necessary date for constants optimization with AutoDiff
+    /// </summary>
+    /// <param name="dataset">The dataset holding the data.</param>
+    /// <param name="variables">The variables for which the data from the dataset should be extracted.</param>
+    /// <param name="rows">The rows for which the data should be extracted.</param>
+    /// <returns>A two-dimensiona double array containing the input data.</returns>
+    public static double[,] ExtractData(IDataset dataset, IEnumerable<VariableData> variables, IEnumerable<int> rows) {
+      if (dataset == null) throw new ArgumentNullException("dataset");
+      if (variables == null) throw new ArgumentNullException("variables");
+      if (rows == null) throw new ArgumentNullException("rows");
+
+      var x = new double[rows.Count(), variables.Count()];
+
+      int col = 0;
+      foreach (var variable in variables) {
+        if (dataset.VariableHasType<double>(variable.variableName)) {
+          IEnumerable<double> values;
+          if (variable.lag == 0)
+            values = dataset.GetDoubleValues(variable.variableName, rows);
+          else
+            values = dataset.GetDoubleValues(variable.variableName, rows.Select(r => r + variable.lag));
+
+          int row = 0;
+          foreach (var value in values) {
+            x[row, col] = value;
+            row++;
+          }
+        } else if (dataset.VariableHasType<string>(variable.variableName)) {
+          var values = dataset.GetStringValues(variable.variableName, rows);
+
+          int row = 0;
+          foreach (var value in values) {
+            x[row, col] = value == variable.variableValue ? 1 : 0; ;
+            row++;
+          }
+        } else throw new NotSupportedException("found a variable of unknown type");
+        col++;
+      }
+
+      return x;
+    }
+
+    /// <summary>
+    /// Extracts all numeric nodes from a symbolic expression tree that can be optimized by the constants optimization
+    /// </summary>
+    /// <param name="tree">The tree from which the numeric nodes should be extracted.</param>
+    /// <returns>A list containing all nodes with numeric coefficients.</returns>
+    public static List<ISymbolicExpressionTreeNode> ExtractNumericNodes(ISymbolicExpressionTree tree) {
+      if (tree == null) throw new ArgumentNullException("tree");
+
+      var nodes = new List<ISymbolicExpressionTreeNode>();
+      foreach (var node in tree.IterateNodesPrefix().OfType<SymbolicExpressionTreeTerminalNode>()) {
+        ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
+        VariableTreeNodeBase variableTreeNodeBase = node as VariableTreeNodeBase;
+        FactorVariableTreeNode factorVarTreeNode = node as FactorVariableTreeNode;
+        if (constantTreeNode != null) nodes.Add(constantTreeNode);
+        else if (variableTreeNodeBase != null) nodes.Add(variableTreeNodeBase);
+        else if (factorVarTreeNode != null) nodes.Add(variableTreeNodeBase);
+        else throw new NotSupportedException(string.Format("Terminal nodes of type {0} are not supported.", node.GetType().GetPrettyName()));
+      }
+      return nodes;
+    }
+
+    /// <summary>
+    /// Extracts all numeric constants from a symbolic expression tree.
+    /// </summary>
+    /// <param name="tree">The tree from which the numeric constants should be extracted.</param>
+    /// <param name="addLinearScalingConstants">Flag to determine whether constants for linear scaling have to be added at the end.
+    /// α *f(x) + β, α = 1.0,  β = 0.0 </param>
+    /// <returns> An array containing the numeric constants.</returns>
+    public static double[] ExtractConstants(ISymbolicExpressionTree tree, bool addLinearScalingConstants) {
+      if (tree == null) throw new ArgumentNullException("tree");
+      return ExtractConstants(tree.IterateNodesPrefix().OfType<SymbolicExpressionTreeTerminalNode>(), addLinearScalingConstants);
+    }
+
+    /// <summary>
+    /// Extracts all numeric constants from a list of nodes.
+    /// </summary>
+    /// <param name="nodes">The list of nodes for which the numeric constants should be extracted.</param>
+    /// <param name="addLinearScalingConstants">Flag to determine whether constants for linear scaling have to be added at the end.
+    /// α *f(x) + β, α = 1.0,  β = 0.0 </param>
+    /// <returns> An array containing the numeric constants.</returns>
+    public static double[] ExtractConstants(IEnumerable<ISymbolicExpressionTreeNode> nodes, bool addLinearScalingConstants) {
+      if (nodes == null) throw new ArgumentNullException("nodes");
+
       var constants = new List<double>();
-      foreach (var node in tree.IterateNodesPrefix().OfType<SymbolicExpressionTreeTerminalNode>()) {
+      foreach (var node in nodes) {
         ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
         VariableTreeNodeBase variableTreeNodeBase = node as VariableTreeNodeBase;
@@ -90 +155 @@
           for (int j = 0; j < factorVarTreeNode.Weights.Length; j++)
             constants.Add(factorVarTreeNode.Weights[j]);
-        } else throw new NotSupportedException(string.Format("Terminal nodes of type {0} are not supported.", node.GetType().GetPrettyName()));
-      }
+        } else throw new NotSupportedException(string.Format("Nodes of type {0} are not supported.", node.GetType().GetPrettyName()));
+      }
+      constants.Add(1.0);
+      constants.Add(0.0);
       return constants.ToArray();
     }
 
-    public static void UpdateConstants(ISymbolicExpressionTree tree, double[] constants) {
+    /// <summary>
+    /// Sets the numeric constants of the nodes to the provided values.
+    /// </summary>
+    /// <param name="nodes">The nodes whose constants should be updated.</param>
+    /// <param name="constants">The numeric constants which should be set. </param>
+    public static void UpdateConstants(IEnumerable<ISymbolicExpressionTreeNode> nodes, double[] constants) {
+      if (nodes == null) throw new ArgumentNullException("nodes");
+      if (constants == null) throw new ArgumentNullException("constants");
+
       int i = 0;
-      foreach (var node in tree.Root.IterateNodesPrefix().OfType<SymbolicExpressionTreeTerminalNode>()) {
+      foreach (var node in nodes) {
         ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
         VariableTreeNodeBase variableTreeNodeBase = node as VariableTreeNodeBase;
@@ -111 +186 @@
       }
     }
+
+    /// <summary>
+    /// Sets all numeric constants of the symbolic expression tree to the provided values.
+    /// </summary>
+    /// <param name="tree">The tree for which the numeric constants should be updated.</param>
+    /// <param name="constants">The numeric constants which should be set.</param>
+    public static void UpdateConstants(ISymbolicExpressionTree tree, double[] constants) {
+      if (tree == null) throw new ArgumentNullException("tree");
+      if (constants == null) throw new ArgumentNullException("constants");
+      UpdateConstants(tree.IterateNodesPrefix().OfType<SymbolicExpressionTreeTerminalNode>(), constants);
+    }
   }
 }